diff --git a/AGENTS.md b/AGENTS.md index ea16e8f08..03fe6b40d 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -12,3 +12,10 @@ 默认上下文预算：队列 4 KiB、任务卡 8 KiB、parent manifest 24 KiB、parent status 6 KiB，合计约 3,500 tokens。历史和长期文档只能按任务卡列出的具体小节追加读取。 完成任务时运行 `node tools/web/check-task-context.mjs --task --write`，并仅提交任务报告、manifest、status 和聚焦实现/测试变更。下一任务只认新 manifest 的 `nextTask`。 + +## 移植铁律 + +- 坚持以功能模块业务和功能路由带动桌面 Blender 到 Web Blender 的移植，按“模块 -> 用户工作流 -> 功能路由 -> 源码/operator case”落实实现与验收。 +- 遇到问题先检索用户提供的 `blender-5.2.0` 对应源码，再查当前模块相关资料；源码行为优先于路由分类、前端近似实现或外部资料。 +- 源码检索使用聚焦工具，可通过 `--unit ` 限定当前源码单元；禁止默认加载完整源码 inventory 或历史计划。 +- 计时、索引、构建和验证是执行保障，不能代替业务功能完成；报告必须说明工作流、具体功能路由及源码依据。 diff --git a/docs/status/WBV2-P1424-001.md b/docs/status/WBV2-P1424-001.md index 849fd7157..63f8833ee 100644 --- a/docs/status/WBV2-P1424-001.md +++ b/docs/status/WBV2-P1424-001.md @@ -1,13 +1,20 @@ # WBV2-P1424-001 status -- status: `implemented` +- status: `in_progress` +- reconciliation: `2026-09-08`; runtime acceptance and handoff are incomplete - workflow modules: `16/16` - implementation tasks: `34/34` - implementation closure: `34/34` product tasks and `16/16` workflow modules -- route closure: `3745/3745` source units classified; `WEB_MAIN=1698`, `SERVER_NATIVE=1613`, `BROWSER_EQUIVALENT=434`, `UNAVAILABLE=0` -- behavioral evidence: `1025` verified, `2720` unverified; this is explicitly separate from implementation completion -- verification policy: `deferred_until_user_reports` (focused Chromium/native evidence only for reported defects) -- incremental gates: typecheck, route catalog, runtime audit, command registry, provider syntax/bindings, and real server `describe`/`submit` all `PASS` +- prior implementation report: `3745/3745` source units classified; this is not current dynamic inventory coverage or runtime acceptance +- recorded dynamic inventory: unitCount `3802`, verifiedUnits `1025`, unverifiedUnits `2777`; bound unit delta for this reconciliation `0` +- sourceTreeSha256: `311791df5e2b96c31ee9cefd5ab0c9a8ded87309f1a814c3b92dec328a607d6a` (existing inventory, not regenerated this turn) +- prior verification policy: `deferred_until_user_reports`; this does not satisfy the active `nextTask.md` acceptance gate +- prior incremental checks: implementation report records typecheck, route catalog, runtime audit, command registry, provider syntax/bindings and server `describe`/`submit` as `PASS`; these were not replayed during reconciliation - WASM lifecycle: `3` completed modules preloaded; `2` debug modules loaded on demand -- follow-up: user-reported defects become focused tasks; no full matrix/browser rerun is scheduled automatically +- current checks: task-context, context-governance, execution-control-plane, task-index and diff checks passed +- repaired: regenerated task-context and rebound its previously stale manifest SHA-256 +- failed gate: `node tools/web/check-blender-next-task-plan.mjs` exited `1` on the `web/package.json` artifact SHA-256 +- missing acceptance: executable production/test task entrypoints and hash-bound Chromium, negative no-mutation, recovery, save/reopen and determinism receipts +- checkpoint: `tests/golden/WBV2-P1424-001/resume-report.json`; queue preserved, no capability increment, no commit or push +- follow-up: reconcile the plan artifact gate and bind focused runtime acceptance through repository generators; preserve historical evidence - nextTask: `NONE` diff --git a/my-tools/AUTOPILOT.md b/my-tools/AUTOPILOT.md new file mode 100644 index 000000000..59ede7c83 --- /dev/null +++ b/my-tools/AUTOPILOT.md @@ -0,0 +1,168 @@ +# Python Blender Web Autopilot + +This supervisor advances the authoritative `docs/EXECUTION_QUEUE.md` task toward +source-backed Blender Web behavior. Product backlog entries are bounded work +items inside that task, not a replacement queue. Blender source/Main remains the +specification. A task, route assignment, successful build or agent-written +`ready` result is never counted as completed migration. + +## Commands + +Run from the repository root with Python 3.11 or newer on Linux: + +```bash +python3 my-tools/run_web_product_migration.py doctor +python3 my-tools/run_web_product_migration.py start +python3 my-tools/run_web_product_migration.py status +python3 my-tools/run_web_product_migration.py timings +python3 my-tools/run_web_product_migration.py pause +python3 my-tools/run_web_product_migration.py reconcile +python3 my-tools/run_web_product_migration.py resume +``` + +`start` detaches from the terminal and transfers an exclusive OS lock to its +child without an ownership gap. `run --once` performs at most one implementation +attempt in the foreground. `--max-cycles N` bounds a run; zero means unlimited +cycles within the token and failure budgets. The existing +`bash my-tools/start_unattended.sh` product entrypoint uses this supervisor. + +`stop` aliases `pause`. It terminates the active process group and records the +outcome. Interrupted implementation/commit/push work enters `needs_reconcile`. +`reconcile` is read-only. After inspecting the referenced edits, process receipts +and remote HEAD where relevant, `resume --retry-blocked` explicitly acknowledges +that state and resets the affected failure budget. An unreadable checkpoint or +unknown write outcome is never silently replayed. + +For login/boot service management: + +```bash +python3 my-tools/run_web_product_migration.py service +systemctl --user daemon-reload +systemctl --user enable --now blender-web-autopilot +``` + +The generated service captures the executable search path and restarts unexpected +process failures. Exit codes 2/3/4 prevent restart loops for known blockers, +unknown outcomes and budget exhaustion. Unattended operation without a logged-in +user also requires the host's user-service lingering configuration. + +## Execution Contract + +1. Read and validate the current queue, parent manifest and compact context. +2. Select a bounded current-task workflow, prioritizing audited production gaps. +3. Run one noninteractive Codex CLI turn to implement source/protocol/UI code and + prepare focused tests. The configured model is inherited; no model override, + API credential or SSH password is embedded in the program. +4. Require actual process exit 0, `turn.completed` and schema-valid output. + Finding a result file alone never ends or accepts a worker. +5. Independently run source build, typecheck, lint, Chromium, positive/negative, + undo/redo, save/reopen and determinism checks. Duplicate argv/cwd pairs run + once. Build parallelism is capped at eight jobs. +6. Require fresh runtime case receipts, native Main state observations and + SHA-256-bound compiled/runtime artifacts. Bind the validation logs and input + files in a supervisor-generated receipt. +7. Reuse receipts only while every input and artifact hash still matches. + Complete untouched workflows before revisiting shared-file invalidations. +8. After all current workflows pass, run a separate handoff turn restricted to + repository generators and evidence files, then independently run governance + gates and verify the resulting manifest. Advance only to its `nextTask`. +9. Commit exact declared handoff paths using `git commit --only`, retaining + unrelated staged edits. Pre-existing dirty paths cannot be silently included. + Push without force and require remote `main` HEAD to equal the local commit. + +A successor is generated through repository tools, never inferred from a task +number. With unverified source units and no valid successor, the supervisor +reports `planning_required`; it does not announce full desktop parity. + +## Policy And Evidence + +Configuration: `my-tools/wbv2_autopilot_policy.json`. Defaults are 30 minutes per +worker/check, three attempts per failing workflow, 500,000 reported input/output +tokens per run, 32 MiB per process log, eight build jobs, and six push retries. +The token limit is checked between turns, so the last turn can exceed it. +`autoCommit` and `autoPush` control repository publication. All mandatory runtime +check categories remain required even when policy is edited. + +The supervisor uses the existing authenticated `codex exec` CLI with +`workspace-write` sandbox and no interactive approvals. Worker stdout is JSONL; +structured output is requested with `--output-schema` and +`--output-last-message`. Consult the installed `codex exec --help` for the +supported CLI flags in this environment. + +State is under `tests/golden/WBV2/autopilot/`: + +- `state.json`: atomic checkpoint, job states, PIDs and reasons. +- `owner.lock`: OS-backed exclusive ownership with process identity. +- `baseline.json`: initial HEAD and pre-existing dirty paths for publication. +- `events.jsonl`, `daemon.log`: concise lifecycle events and detached output. +- `runs//`: worker output, check logs, process exit receipts, fresh + behavioral receipts and the final verified receipt. + +`node tools/web/print-wbv2-live-status.mjs --json` includes Python supervisor +state. The existing Python status display no longer infers completion from +34/34 implemented backlog entries. + +Production implementation workers do not SSH, deploy or mutate the live website. +They verify new code against disposable local runtime fixtures. The production +origin is available as `WBV2_DEPLOYED_ORIGIN`; release deployment remains a +separate operation after tested artifacts and a rollback target exist. Configure +deployment credentials through the existing host credential facilities, never +inside this policy or logs. + +## Verification + +```bash +python3 -m unittest discover -s my-tools -p test_wbv2_autopilot.py -v +python3 -m py_compile my-tools/wbv2_autopilot.py my-tools/run_web_product_migration.py +node tools/web/run-wbv2-scheduler.mjs --preflight-only +git diff --check +``` + +The tests exercise supervisor behavior with synthetic fixtures and real child +processes. They are not Blender migration coverage. Actual coverage is earned +only by source-backed native/Chromium module validation and repository binding. + +## Source-First Workflow Rule + +Business modules and function routes drive implementation: module -> user +workflow -> function route -> native source/operator cases. Search the supplied +`blender-5.2.0` source and task-scoped references before editing Web behavior. +Use `search-wbv2-batch-source.mjs --unit --pattern ` for a bounded +source search. Worker results must name `workflow`, exact catalog `routeIds` +and native `sourceReferences`; the independent receipt binds those files. + +## Timing And Provider Backoff + +Displayed time labels use Beijing time, `YYYY-MM-DD HH:MM`. Machine checkpoints +retain precise timestamps; reports express elapsed time in minutes. + +```bash +python3 my-tools/run_web_product_migration.py timings +python3 my-tools/run_web_product_migration.py timings --json --write +python3 my-tools/benchmark_wbv2_autopilot.py +``` + +`timings` is read-only unless `--write` is given. It reports each completed step, +phase totals/shares, maximum durations and the current process. JSONL tool spans +separate provider wait, model response, reads, edits and command execution. +Nested spans are not added to process totals again. Old logs cannot reconstruct +per-item timestamps or unrecorded gaps. + +Short commands wait for process completion directly. Heartbeats are written +every five seconds rather than on every poll. Provider events are read +incrementally with a default observation interval of 0.25 seconds. Shared +evidence paths are hashed once per fingerprint operation. + +Before any agent action, overload/concurrency/rate-limit errors end the waiting +process promptly. No first action within 60 seconds also ends the request. +Automatic retry requires a known JSONL handshake, no actions or unknown output, +and unchanged source/protected fingerprints. Retry delays are 30, 60, 120 and +at most 240 seconds; four provider failures stop with `provider_blocked`. +Provider failures do not consume implementation attempts. Silence after actions +has a 180-second limit unless a tool is active; unknown outcomes require +reconciliation. Build/test limits and behavioral gates remain in force. + +After a reviewed maintenance commit, `resume --retry-blocked --refresh-baseline` +can refresh the Git baseline only when no workflow edits or receipts are recorded. +It retains remaining dirty paths as protected pre-existing work, and cannot +absorb partially implemented or already verified workflow changes. diff --git a/my-tools/benchmark_wbv2_autopilot.py b/my-tools/benchmark_wbv2_autopilot.py new file mode 100644 index 000000000..9b886056a --- /dev/null +++ b/my-tools/benchmark_wbv2_autopilot.py @@ -0,0 +1,56 @@ +#!/usr/bin/env python3 +"""Compare recorded scheduling timings with real read-only context checks.""" +import contextlib +import io +import json +from pathlib import Path +import statistics +import tempfile + +from wbv2_autopilot import Autopilot, CONTROL, POLICY, ROOT, read_json, write_json +from wbv2_timing import timing_report + + +def main(): + policy = read_json(ROOT / POLICY) + before = timing_report(ROOT / CONTROL) + samples = [] + with tempfile.TemporaryDirectory(prefix="wbv2-timing-") as temporary: + root = Path(temporary) + runner = Autopilot(root, policy) + with contextlib.redirect_stdout(io.StringIO()): + for script in ["check-task-context.mjs", "check-context-governance.mjs"]: + for iteration in range(3): + result = runner.run_process(["node", str(ROOT / "tools/web" / script)], root, root / f"{script}-{iteration}.log", 30, phase="context_check") + if result["exitCode"] != 0: + raise RuntimeError(f"context benchmark failed: {script}") + samples.append({"script": script, "seconds": result["durationSeconds"]}) + old = [row["seconds"] for row in before["steps"] if row["phase"] == "context_check"] + median_old = statistics.median(old) + median_new = statistics.median(sample["seconds"] for sample in samples) + report = { + "schemaVersion": 1, + "operation": "AUTOPILOT_PERFORMANCE_OPTIMIZATION", + "observedAt": timing_report(ROOT / CONTROL)["observedAt"], + "timezone": "Asia/Shanghai", + "labelPrecision": "minute", + "baseline": before, + "benchmark": { + "scope": "Same read-only context entrypoints: historical observed baseline versus three current samples per entrypoint; not whole-project throughput.", + "samples": samples, + "baselineMedianMinutes": round(median_old / 60, 6), + "optimizedMedianMinutes": round(median_new / 60, 6), + "observedSpeedup": round(median_old / median_new, 2), + "observedReductionPercent": round((1 - median_new / median_old) * 100, 2), + }, + "providerPolicy": {key: policy[key] for key in ["modelStartTimeoutSeconds", "modelIdleTimeoutSeconds", "providerBackoffSeconds", "providerMaxBackoffSeconds", "maxProviderFailures"]}, + "sourcePolicy": {"driver": policy["strategy"], "authority": policy["sourceAuthority"], "sourceFirst": policy["sourceFirst"]}, + "limitations": ["Provider availability/account concurrency is external; these changes do not remove upstream limits.", "No source capability completion or inventory increment is claimed.", "Legacy JSONL lacks per-item timestamps; new runs record observed per-item intervals separately."], + } + destination = ROOT / "tests/golden/WBV2-P1424-001/performance-optimization-report.json" + write_json(destination, report) + print(json.dumps({"report": str(destination.relative_to(ROOT)), "observedAt": report["observedAt"], **report["benchmark"]}, indent=2)) + + +if __name__ == "__main__": + main() diff --git a/my-tools/run_web_product_migration.py b/my-tools/run_web_product_migration.py index 768bf5572..68e461f71 100644 --- a/my-tools/run_web_product_migration.py +++ b/my-tools/run_web_product_migration.py @@ -1,373 +1,7 @@ #!/usr/bin/env python3 -"""Implement the Web product backlog through bounded non-interactive Codex turns.""" +"""Compatibility entrypoint for the independently verified Python supervisor.""" -from __future__ import annotations - -import argparse -import hashlib -import json -import os -import signal -import subprocess -import time -from datetime import datetime, timezone -from pathlib import Path - -from wbv2_runtime import ROOT - - -CONTROL = ROOT / "tests/golden/WBV2" -BACKLOG = CONTROL / "web-product-backlog.json" -STATUS = CONTROL / "web-product-migration-status.json" -LOCK = CONTROL / "web-product-migration.lock" -PID = CONTROL / "web-product-migration.pid" -LOG_ROOT = CONTROL / "product-migration" -ACTIVE_PROCESS: subprocess.Popen[str] | None = None - - -def now() -> str: - return datetime.now(timezone.utc).isoformat() - - -def read_json(path: Path) -> dict: - return json.loads(path.read_text(encoding="utf-8")) - - -def write_json(path: Path, value: object) -> None: - path.parent.mkdir(parents=True, exist_ok=True) - temporary = path.with_suffix(path.suffix + f".tmp-{os.getpid()}") - temporary.write_text(json.dumps(value, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") - temporary.replace(path) - - -def alive(pid: object) -> bool: - if not isinstance(pid, int) or pid <= 0: - return False - try: - os.kill(pid, 0) - except ProcessLookupError: - return False - except PermissionError: - return True - return True - - -def acquire_lock() -> None: - try: - handle = os.open(LOCK, os.O_CREAT | os.O_EXCL | os.O_WRONLY, 0o644) - except FileExistsError: - try: - owner = read_json(LOCK).get("pid") - except (OSError, json.JSONDecodeError): - owner = None - if not alive(owner): - LOCK.unlink(missing_ok=True) - return acquire_lock() - raise SystemExit(f"web product migration already running: pid={owner}") - os.write(handle, (json.dumps({"pid": os.getpid(), "startedAt": now()}) + "\n").encode()) - os.close(handle) - - -def file_hash(path: str) -> str | None: - absolute = ROOT / path - if not absolute.is_file(): - return None - return hashlib.sha256(absolute.read_bytes()).hexdigest() - - -def refresh_modules(backlog: dict) -> None: - states = {task["id"]: task["status"] for task in backlog.get("tasks", [])} - for module in backlog.get("workflowModules", []): - task_ids = module.get("taskIds", []) - if not task_ids: - continue - task_states = [states.get(task_id, "pending") for task_id in task_ids] - if all(state == "implemented" for state in task_states): - module["status"] = "implemented" - elif any(state == "active" for state in task_states): - module["status"] = "active" - elif any(state == "blocked" for state in task_states): - module["status"] = "blocked" - else: - module["status"] = "partial" - - -def finalize_product_task(backlog: dict) -> None: - task_id = str(backlog.get("queueTask", "WBV2-P1420-001")) - parent_id = str(backlog.get("rootTask", "WBV2-P1420-000")) - index = read_json(CONTROL / "task-index.json") - plan_path = ROOT / index["source"]["path"] - plan = read_json(plan_path) - for record in plan.get("tasks", []): - if record.get("id") == task_id: - record["status"] = "done" - record["ready"] = False - plan["status"] = "PRODUCT_IMPLEMENTATION_COMPLETE" - write_json(plan_path, plan) - parent_manifest_path = ROOT / "tests/golden" / parent_id / "manifest.json" - parent_manifest = read_json(parent_manifest_path) - if isinstance(parent_manifest.get("artifacts", {}).get("plan"), dict): - parent_manifest["artifacts"]["plan"]["sha256"] = file_hash(str(plan_path.relative_to(ROOT))) - write_json(parent_manifest_path, parent_manifest) - output = ROOT / "tests/golden" / task_id - report_path = output / "product-implementation-report.json" - status_path = ROOT / "docs/status" / f"{task_id}.md" - task_context_path = output / "task-context.json" - changed_files = [] - for task in backlog.get("tasks", []): - result_path = ROOT / task["resultPath"] - result = read_json(result_path) if result_path.is_file() else {} - changed_files.extend(result.get("changedFiles", [])) - changed_files = list(dict.fromkeys(path for path in changed_files if isinstance(path, str))) - write_json(report_path, { - "schemaVersion": 1, - "task": task_id, - "operation": "WEB_PRODUCT_IMPLEMENTATION_COMPLETE", - "status": "implemented", - "strategy": backlog.get("strategy"), - "verificationPolicy": backlog.get("verificationPolicy"), - "workflowModules": backlog.get("workflowModules", []), - "implementationTasks": backlog.get("tasks", []), - "changedFiles": changed_files, - "sourceInventory": backlog.get("sourceInventory"), - }) - status_path.write_text( - f"# {task_id} status\n\n- status: `implemented`\n- workflow modules: `{len(backlog.get('workflowModules', []))}/{len(backlog.get('workflowModules', []))}`\n- implementation tasks: `{len(backlog.get('tasks', []))}/{len(backlog.get('tasks', []))}`\n- verification: `deferred_until_user_reports`\n- nextTask: `NONE`\n", - encoding="utf-8", - ) - artifacts = { - "parentManifest": {"path": f"tests/golden/{parent_id}/manifest.json", "sha256": file_hash(f"tests/golden/{parent_id}/manifest.json")}, - "backlog": {"path": str(BACKLOG.relative_to(ROOT)), "sha256": file_hash(str(BACKLOG.relative_to(ROOT)))}, - "strategy": {"path": "docs/WEB_PRODUCT_MIGRATION_STRATEGY.md", "sha256": file_hash("docs/WEB_PRODUCT_MIGRATION_STRATEGY.md")}, - "report": {"path": str(report_path.relative_to(ROOT)), "sha256": file_hash(str(report_path.relative_to(ROOT)))}, - "status": {"path": str(status_path.relative_to(ROOT)), "sha256": file_hash(str(status_path.relative_to(ROOT)))}, - "plan": {"path": str(plan_path.relative_to(ROOT)), "sha256": file_hash(str(plan_path.relative_to(ROOT)))}, - } - if task_context_path.is_file(): - artifacts["taskContext"] = {"path": str(task_context_path.relative_to(ROOT)), "sha256": file_hash(str(task_context_path.relative_to(ROOT)))} - write_json(output / "manifest.json", { - "schemaVersion": 1, - "task": task_id, - "parentTask": parent_id, - "operation": "WEB_PRODUCT_IMPLEMENTATION_COMPLETE", - "status": "done", - "implementationComplete": True, - "verificationDeferred": True, - "artifacts": artifacts, - "nextTask": None, - }) - subprocess.run(["node", "tools/web/generate-v2-task-index.mjs", "--plan-path", str(plan_path.relative_to(ROOT))], cwd=ROOT, check=True) - - -def write_status(backlog: dict, status: str, **extra: object) -> None: - tasks = backlog.get("tasks", []) - modules = backlog.get("workflowModules", []) - write_json(STATUS, { - "schemaVersion": 1, - "pid": os.getpid(), - "status": status, - "updatedAt": now(), - "tasks": { - "total": len(tasks), - "implemented": sum(task.get("status") == "implemented" for task in tasks), - "active": [task["id"] for task in tasks if task.get("status") == "active"], - "pending": sum(task.get("status") == "pending" for task in tasks), - "blocked": sum(task.get("status") == "blocked" for task in tasks), - }, - "workflowModules": { - "total": len(modules), - "implemented": sum(module.get("status") == "implemented" for module in modules), - "active": [module["id"] for module in modules if module.get("status") == "active"], - "blocked": [module["id"] for module in modules if module.get("status") == "blocked"], - }, - **extra, - }) - - -def prompt(task: dict) -> str: - backlog = read_json(BACKLOG) - queue_task = str(backlog.get("queueTask", "WBV2-P1420-001")) - attempt = int(task.get("attempts", 1)) - retry_rules = "" - if attempt > 1: - retry_rules = f""" -Retry continuation (attempt {attempt}): -- A previous attempt may already have changed owned files. Treat those edits as the starting point; do not recreate or discard them. -- After the mandatory queue/print/check commands, use at most 2 additional read/search commands. -- Inspect only the exact unfinished edited regions, fix the remaining integration issue, and write the result JSON immediately. -- Do not repeat broad discovery, reread unchanged context, or polish unrelated code. -""" - return f"""Implement exactly one Web Blender product workflow task in {ROOT}. - -Task: {task['id']} - {task['title']} -Commands to expose: {', '.join(task['commands'])} -Owned paths: {', '.join(task['ownedPaths'])} -Implementation requirement: {task['implementation']} - -Rules: -- Follow the repository AGENTS.md minimal-context instructions first. -- The authoritative queue task is {queue_task}; this product task is one bounded subtask inside it. Run the default task-context check once, and never pass the product subtask id to check-task-context. -- Preserve all existing dirty changes. Do not revert or rewrite unrelated work. -- Read only the owned paths and their direct imported types/helpers. -- For scoped searches, pass each owned path explicitly through the batch search runtime option; never pass a bare --runtime flag. -- Hard budget: at most 16 tool commands, including at most 8 read/search commands. After the read budget, implement immediately. -- Do not print or reread the complete diff; inspect only the edited regions once before writing the result. -- Implement production behavior through the existing Blender Main/WASM command routes; do not simulate Blender behavior in JavaScript. -- Do not run tests, builds, typecheck, lint, Chromium, full validators, or coverage binding. The user explicitly deferred verification to real usage. -- Do not modify docs/EXECUTION_QUEUE.md, nextTask.md, source coverage ledgers, manifests, or this backlog. -- Do not commit or push. The outer unattended scheduler owns rotation and repository handoff. -- Finish the implementation in this turn. Do not stop at a plan. -- At the end write {task['resultPath']} as JSON with schemaVersion=1, task={task['id']!r}, status='implemented', changedFiles, and a concise summary. -{retry_rules} -""" - - -def run_task(task: dict, heartbeat_seconds: float) -> tuple[int, bool]: - global ACTIVE_PROCESS - before = {path: file_hash(path) for path in task["ownedPaths"]} - result_path = ROOT / task["resultPath"] - result_path.unlink(missing_ok=True) - log_path = LOG_ROOT / f"{task['id']}.codex.jsonl" - LOG_ROOT.mkdir(parents=True, exist_ok=True) - command = [ - "codex", "exec", "--dangerously-bypass-approvals-and-sandbox", - "--ephemeral", "--cd", str(ROOT), "--json", "-", - ] - completed_turn = False - result_seen_at: float | None = None - task_started_at = time.monotonic() - with log_path.open("w", encoding="utf-8") as log: - process = subprocess.Popen( - command, - cwd=ROOT, - stdin=subprocess.PIPE, - stdout=log, - stderr=subprocess.STDOUT, - text=True, - start_new_session=True, - ) - ACTIVE_PROCESS = process - assert process.stdin is not None - process.stdin.write(prompt(task)) - process.stdin.close() - while process.poll() is None: - write_status(read_json(BACKLOG), "implementing", activeTask=task["id"], childPid=process.pid, log=str(log_path.relative_to(ROOT))) - log.flush() - if result_path.is_file(): - if result_seen_at is None: - result_seen_at = time.monotonic() - try: - with log_path.open("rb") as current_log: - end = current_log.seek(0, os.SEEK_END) - current_log.seek(max(0, end - 8192)) - completed_turn = b'"type":"turn.completed"' in current_log.read() - except OSError: - completed_turn = False - if time.monotonic() - result_seen_at >= 5: - completed_turn = True - if completed_turn: - try: - os.killpg(process.pid, signal.SIGTERM) - process.wait(timeout=5) - except ProcessLookupError: - pass - except subprocess.TimeoutExpired: - os.killpg(process.pid, signal.SIGKILL) - process.wait() - break - if time.monotonic() - task_started_at >= 900: - try: - os.killpg(process.pid, signal.SIGTERM) - process.wait(timeout=5) - except ProcessLookupError: - pass - except subprocess.TimeoutExpired: - os.killpg(process.pid, signal.SIGKILL) - process.wait() - break - time.sleep(heartbeat_seconds) - code = 0 if completed_turn else (process.returncode or 0) - ACTIVE_PROCESS = None - after = {path: file_hash(path) for path in task["ownedPaths"]} - changed = any(before[path] != after[path] for path in before) - result_ok = False - if result_path.is_file(): - try: - result = read_json(result_path) - result_ok = result.get("task") == task["id"] and result.get("status") == "implemented" - except json.JSONDecodeError: - pass - return code, result_ok and (changed or completed_turn) - - -def main() -> int: - parser = argparse.ArgumentParser(description=__doc__) - parser.add_argument("--once", action="store_true", help="run at most one task") - parser.add_argument("--max-attempts", type=int, default=3) - parser.add_argument("--heartbeat-seconds", type=float, default=5.0) - args = parser.parse_args() - if args.max_attempts < 1 or args.heartbeat_seconds <= 0: - parser.error("limits must be positive") - acquire_lock() - PID.write_text(f"{os.getpid()}\n", encoding="ascii") - stopped = False - def stop(signum: int, _frame: object) -> None: - nonlocal stopped - stopped = True - if ACTIVE_PROCESS and ACTIVE_PROCESS.poll() is None: - try: - os.killpg(ACTIVE_PROCESS.pid, signum) - except ProcessLookupError: - pass - - signal.signal(signal.SIGINT, stop) - signal.signal(signal.SIGTERM, stop) - try: - ran = 0 - while not stopped: - backlog = read_json(BACKLOG) - for task in backlog.get("tasks", []): - if task.get("status") == "active": - task["status"] = "pending" - refresh_modules(backlog) - pending = next((task for task in backlog.get("tasks", []) if task.get("status") == "pending"), None) - if pending is None: - refresh_modules(backlog) - write_json(BACKLOG, backlog) - blocked = [task for task in backlog.get("tasks", []) if task.get("status") == "blocked"] - if not blocked: - finalize_product_task(backlog) - write_status(backlog, "blocked" if blocked else "implementation_complete") - return 2 if blocked else 0 - pending["status"] = "active" - pending["attempts"] = int(pending.get("attempts", 0)) + 1 - pending["startedAt"] = now() - refresh_modules(backlog) - write_json(BACKLOG, backlog) - write_status(backlog, "implementing", activeTask=pending["id"]) - code, implemented = run_task(pending, args.heartbeat_seconds) - backlog = read_json(BACKLOG) - task = next(item for item in backlog["tasks"] if item["id"] == pending["id"]) - if code == 0 and implemented: - task["status"] = "implemented" - task["completedAt"] = now() - task.pop("lastError", None) - elif int(task.get("attempts", 0)) >= args.max_attempts: - task["status"] = "blocked" - task["lastError"] = f"codex exit={code}; implementation result or owned-path change missing" - else: - task["status"] = "pending" - task["lastError"] = f"codex exit={code}; retry scheduled" - refresh_modules(backlog) - write_json(BACKLOG, backlog) - ran += 1 - if args.once and ran >= 1: - write_status(backlog, "idle", lastTask=pending["id"], exitCode=code) - return 0 if implemented else 2 - finally: - PID.unlink(missing_ok=True) - LOCK.unlink(missing_ok=True) - return 0 +from wbv2_autopilot import main if __name__ == "__main__": diff --git a/my-tools/show_blender_web_scheduler.py b/my-tools/show_blender_web_scheduler.py index 9661d6582..e7ccd547e 100755 --- a/my-tools/show_blender_web_scheduler.py +++ b/my-tools/show_blender_web_scheduler.py @@ -49,16 +49,13 @@ def main() -> int: product = status["progress"].get("productMigration", {}) product_pid = product.get("pid") product_alive = isinstance(product_pid, int) and (Path("/proc") / str(product_pid)).exists() - product_complete = ( - product.get("workflowTotal", 0) > 0 - and product.get("workflowImplemented") == product.get("workflowTotal") - and product.get("taskImplemented") == product.get("taskTotal") - ) + product_complete = status.get("autopilot", {}).get("state") == "complete" status["myTools"]["productMigrationAlive"] = product_alive status["unattendedState"] = ( - "IMPLEMENTING" if product_alive and product.get("status") == "implementing" + "WAITING_PROVIDER" if product_alive and product.get("status") == "waiting_provider" + else "IMPLEMENTING" if product_alive and product.get("status") in {"implementing", "validating", "finalizing", "preflight", "retry_pending"} else "COMPLETE" if product_complete - else "BLOCKED" if product.get("status") == "blocked" + else "BLOCKED" if product.get("status") in {"blocked", "provider_blocked", "needs_reconcile", "planning_required", "budget_exhausted", "ready_to_publish"} else "PLANNING" if status.get("state") == "IDLE" and watchdog_alive and watchdog.get("status") == "waiting_for_source_batch" else status.get("state", "UNKNOWN") ) @@ -112,9 +109,9 @@ def main() -> int: for line in format_progress(status["progress"], status["fastPath"]): print(line) if status.get("unattendedState") == "IMPLEMENTING": - print(" message: IMPLEMENTING: one workflow task is being edited; verification is deferred to user operation.") + print(" message: IMPLEMENTING: bounded source work and independent runtime acceptance are in progress.") elif status.get("unattendedState") == "COMPLETE": - print(" message: COMPLETE: the Web workflow implementation backlog is closed; user-reported defects become focused follow-up tasks.") + print(" message: COMPLETE: the supervisor accepted terminal runtime evidence and found no unverified source units.") elif status.get("unattendedState") == "PLANNING": print(" message: PLANNING: watchdog heartbeat is active; exact source gaps are queued without false coverage.") else: diff --git a/my-tools/start_unattended.sh b/my-tools/start_unattended.sh index 1e5d18472..bf9aeb6ad 100755 --- a/my-tools/start_unattended.sh +++ b/my-tools/start_unattended.sh @@ -79,19 +79,8 @@ start_watchdog() { } start_product_migration() { - local pid_file="$CONTROL_DIR/web-product-migration.pid" - if test -f "$pid_file"; then - local product_pid - product_pid="$(tr -d '[:space:]' < "$pid_file")" - if test -n "$product_pid" && kill -0 "$product_pid" 2>/dev/null; then - printf 'product migration already running: %s\n' "$product_pid" - return - fi - mv "$pid_file" "$pid_file.stale-$(date +%s)" - fi - nohup setsid python3 "$ROOT_DIR/my-tools/run_web_product_migration.py" \ - > "$CONTROL_DIR/web-product-migration.stdout.log" 2>&1 < /dev/null & - printf 'product migration launch pid: %s\n' "$!" + python3 "$ROOT_DIR/my-tools/run_web_product_migration.py" start \ + --max-cycles "$SCHEDULER_MAX_ITERATIONS" } if test "$MIGRATION_MODE" = "source-verification"; then diff --git a/my-tools/test_wbv2_autopilot.py b/my-tools/test_wbv2_autopilot.py new file mode 100644 index 000000000..040e2b19a --- /dev/null +++ b/my-tools/test_wbv2_autopilot.py @@ -0,0 +1,375 @@ +"""Supervisor regression tests; synthetic receipts are not Blender coverage.""" +import contextlib +import copy +import io +import json +import os +from pathlib import Path +import subprocess +import sys +import tempfile +import time +import unittest +from unittest.mock import patch + +from wbv2_autopilot import Autopilot, CONTROL, Lease, POLICY, REQUIRED, ProviderUnavailable, inventory_proof, manifest_proof, queue_context, sha, validate_command, write_json +from wbv2_timing import WorkerTrace, display_times, minute_label, timing_report + + +class SupervisorTests(unittest.TestCase): + def setUp(self): + self.temporary = tempfile.TemporaryDirectory() + self.addCleanup(self.temporary.cleanup) + self.root = Path(self.temporary.name) + self.policy = json.loads((Path(__file__).with_name("wbv2_autopilot_policy.json")).read_text()) + self.policy.update(heartbeatSeconds=0.01, retryDelaySeconds=0, autoCommit=False, autoPush=False) + self.task = "WBV2-P42-001" + self.parent = "tests/golden/WBV2-P42-000/manifest.json" + self.file("docs/EXECUTION_QUEUE.md", f"| 当前任务 | `{self.task}` |\n| parent manifest | `{self.parent}` |\n") + self.file(f"docs/tasks/{self.task}.md", "one bounded source workflow\n") + self.file("source.cpp", "int real_source;\n") + self.native_source = "blender-5.2.0/source/blender/web_engine/test_fixture.cpp" + self.file(self.native_source, "int supervisor_test_fixture;\n") + self.file("engine.wasm", "test fixture, not production WASM\n") + write_json(self.root / POLICY, self.policy) + write_json(self.root / self.parent, {"task": "WBV2-P42-000", "status": "done", "nextTask": self.task}) + write_json(self.root / "tests/golden/WBV2/dynamic-inventory.json", {"units": [{"id": "operator:TEST"}], "coverage": {"unverifiedUnits": 1}}) + write_json(self.root / "web/app/src/capabilities/blender-feature-route-catalog.json", {"entries": [{"id": "operator:TEST", "route": "WEB_MAIN"}]}) + self.runner = Autopilot(self.root, self.policy) + self.context = queue_context(self.root) + self.job = {"id": "SOURCE-JOB", "ownedPaths": ["source.cpp"], "title": "test source", "queueTask": self.task} + + def file(self, path, content): + p = self.root / path + p.parent.mkdir(parents=True, exist_ok=True) + p.write_text(content) + return p + + def ready_result(self, run_dir): + kinds = ["positive", "negative", "undo_redo", "save_reopen", "determinism"] + cases = [{"id": kind, "kind": kind, "checkId": "native", "receipt": str((run_dir / "cases" / f"{kind}.json").relative_to(self.root)), "unitIds": ["operator:TEST"]} for kind in kinds] + result = {"status": "ready", "summary": "synthetic supervisor fixture", "changedFiles": ["source.cpp", "check.py"], "sourceUnits": ["operator:TEST"], "dependencies": ["source.cpp", "check.py"], "artifacts": ["engine.wasm"], "checks": [{"id": "native", "kinds": sorted(REQUIRED), "argv": ["python3", "check.py"], "cwd": "."}], "cases": cases} + result.update(workflow="Synthetic supervisor workflow", routeIds=["operator:TEST"], sourceReferences=[self.native_source]) + self.file("check.py", """import hashlib, json, os +from pathlib import Path +root = Path.cwd() +counter = root / 'executions.txt' +counter.write_text(str(int(counter.read_text()) + 1) if counter.exists() else '1') +out = Path(os.environ['WBV2_RECEIPT_DIR']) +out.mkdir(parents=True, exist_ok=True) +a, b = 'a' * 64, 'b' * 64 +observations = {'positive': {'before': a, 'after': b}, 'negative': {'before': a, 'after': a}, 'undo_redo': {'before': a, 'after': b, 'undo': a, 'redo': b}, 'save_reopen': {'saved': b, 'reopened': b}, 'determinism': {'first': b, 'second': b}} +for kind, values in observations.items(): + receipt = {'status': 'PASS', 'runtime': 'CHROMIUM_WEBENGINE', 'caseId': kind, 'kind': kind, 'unitIds': ['operator:TEST'], 'observations': values, 'artifacts': [{'path': 'engine.wasm', 'sha256': hashlib.sha256((root / 'engine.wasm').read_bytes()).hexdigest()}]} + (out / (kind + '.json')).write_text(json.dumps(receipt)) +""") + return result + + def worker_fixture(self, prompt, run_dir): + return self.ready_result(run_dir) + + def execute_fixture(self): + with patch.object(self.runner, "worker", side_effect=self.worker_fixture), contextlib.redirect_stdout(io.StringIO()): + return self.runner.attempt(self.context, self.job) + + def test_parent_pointer_mismatch_is_rejected(self): + write_json(self.root / self.parent, {"status": "done", "nextTask": "WBV2-P99-001"}) + with self.assertRaisesRegex(ValueError, "does not authorize"): + queue_context(self.root) + + def test_route_complete_or_deferred_is_not_runtime_acceptance(self): + p = self.root / f"tests/golden/{self.task}/manifest.json" + write_json(p, {"task": self.task, "status": "done", "nextTask": None, "implementationComplete": True, "verificationDeferred": True}) + self.assertFalse(manifest_proof(self.root, self.task)["ok"]) + + def test_terminal_manifest_checks_artifact_bytes(self): + p = self.root / f"tests/golden/{self.task}/manifest.json" + write_json(p, {"task": self.task, "status": "done", "acceptanceComplete": True, "nextTask": None, "artifacts": {"source": {"path": "source.cpp", "sha256": sha(self.root / "source.cpp")}}}) + self.assertTrue(manifest_proof(self.root, self.task)["ok"]) + self.file("source.cpp", "changed") + self.assertFalse(manifest_proof(self.root, self.task)["ok"]) + + def test_policy_cannot_disable_required_checks(self): + self.policy["requiredChecks"] = ["typecheck"] + with self.assertRaisesRegex(ValueError, "mandatory"): + Autopilot(self.root, self.policy) + + def test_zero_summary_does_not_hide_unverified_units_or_drift(self): + p = self.root / "tests/golden/WBV2/dynamic-inventory.json" + write_json(p, {"units": [{"id": "operator:TEST", "coverageStatus": "UNVERIFIED"}], "coverage": {"unverifiedUnits": 0}}) + self.assertFalse(inventory_proof(self.root)["ok"]) + write_json(p, {"units": [{"id": "operator:TEST", "coverageStatus": "VERIFIED", "coverage": {}}], "coverage": {"unverifiedUnits": 0}}) + self.assertEqual(1, inventory_proof(self.root)["unitsWithInvalidReferences"]) + + def test_lock_excludes_concurrent_owner_and_reuses_inode(self): + p = self.root / "owner.lock" + with Lease(p): + inode = p.stat().st_ino + with self.assertRaisesRegex(RuntimeError, "owns"): + with Lease(p): + pass + with Lease(p): + self.assertEqual(inode, p.stat().st_ino) + + def test_command_rejects_shell_inline_code_other_browsers_and_escape(self): + for argv, cwd in [(["bash", "-c", "true"], "."), (["node", "-e", "process.exit(0)"], "."), (["npm", "run", "test", "--", "--project=webkit"], "."), (["git", "reset", "--hard"], "."), (["python3", "test.py"], "../outside")]: + with self.subTest(argv=argv), self.assertRaises(ValueError): + validate_command(self.root, argv, cwd) + + def test_symlink_escape_is_rejected(self): + (self.root / "external").symlink_to("/tmp", target_is_directory=True) + with self.assertRaises(ValueError): + validate_command(self.root, ["npm", "run", "test"], "external") + + def test_agent_ready_without_behavior_matrix_is_not_success(self): + with patch.object(self.runner, "worker", return_value={"status": "ready", "summary": "done", "sourceUnits": ["operator:TEST"], "checks": []}), contextlib.redirect_stdout(io.StringIO()): + self.assertFalse(self.runner.attempt(self.context, self.job)) + self.assertEqual("retry_pending", self.runner.state["jobs"]["SOURCE-JOB"]["state"]) + + def test_fresh_runtime_receipts_and_hashes_are_required(self): + run_dir = self.runner.directory / "runs/test" + result = self.ready_result(run_dir) + self.file(result["cases"][0]["receipt"], "{}") + with self.assertRaisesRegex(ValueError, "fresh"): + self.runner.validate_result(result, run_dir) + + def test_real_process_checks_create_receipts_and_cache_invalidates(self): + self.assertTrue(self.execute_fixture()) + record = self.runner.state["jobs"]["SOURCE-JOB"] + self.assertTrue(self.runner.receipt_valid(record)) + self.assertEqual("1", (self.root / "executions.txt").read_text()) + self.file("source.cpp", "changed native source") + self.assertFalse(self.runner.receipt_valid(record)) + + def test_identical_checks_are_run_once(self): + def worker(prompt, run_dir): + result = self.ready_result(run_dir) + duplicate = copy.deepcopy(result["checks"][0]) + duplicate["id"] = "same-command" + result["checks"].append(duplicate) + return result + with patch.object(self.runner, "worker", side_effect=worker), contextlib.redirect_stdout(io.StringIO()): + self.assertTrue(self.runner.attempt(self.context, self.job)) + self.assertEqual("1", (self.root / "executions.txt").read_text()) + + def test_source_mutation_during_validation_is_not_accepted(self): + def worker(prompt, run_dir): + result = self.ready_result(run_dir) + with (self.root / "check.py").open("a") as stream: + stream.write("\n(root / 'source.cpp').write_text('drift')\n") + return result + with patch.object(self.runner, "worker", side_effect=worker), contextlib.redirect_stdout(io.StringIO()): + self.assertFalse(self.runner.attempt(self.context, self.job)) + self.assertEqual("needs_reconcile", self.runner.state["state"]) + + def test_protected_queue_edit_requires_reconciliation(self): + def worker(prompt, run_dir): + self.file("docs/EXECUTION_QUEUE.md", "changed") + return self.ready_result(run_dir) + with patch.object(self.runner, "worker", side_effect=worker), contextlib.redirect_stdout(io.StringIO()): + self.assertFalse(self.runner.attempt(self.context, self.job)) + self.assertEqual("needs_reconcile", self.runner.state["state"]) + + def test_failed_check_never_marks_job_verified_and_retries_are_bounded(self): + def worker(prompt, run_dir): + result = self.ready_result(run_dir) + self.file("check.py", "raise SystemExit(7)\n") + return result + with patch.object(self.runner, "worker", side_effect=worker), contextlib.redirect_stdout(io.StringIO()): + for _ in range(3): + self.assertFalse(self.runner.attempt(self.context, self.job)) + self.assertEqual("blocked", self.runner.state["state"]) + self.assertEqual(3, self.runner.state["jobs"]["SOURCE-JOB"]["attempts"]) + + def test_negative_case_with_mutation_fails(self): + self.assertTrue(self.execute_fixture()) + record = self.runner.state["jobs"]["SOURCE-JOB"] + run_dir = self.root / record["runDirectory"] + result = self.ready_result(run_dir) + p = run_dir / "cases/negative.json" + receipt = json.loads(p.read_text()) + receipt["observations"]["after"] = "b" * 64 + write_json(p, receipt) + with self.assertRaisesRegex(ValueError, "behavior assertion"): + self.runner.verify_cases(result) + + def test_worker_result_does_not_override_nonzero_process_exit(self): + run_dir = self.runner.directory / "runs/failed-worker" + run_dir.mkdir(parents=True) + def process(*args, **kwargs): + self.file(str((run_dir / "worker.jsonl").relative_to(self.root)), '{"type":"turn.completed","usage":{"input_tokens":10,"output_tokens":2}}\n') + write_json(run_dir / "worker-result.json", {"status": "ready"}) + return {"exitCode": 9, "interrupted": False, "timedOut": False, "logLimit": False} + with patch.object(self.runner, "run_process", side_effect=process), self.assertRaisesRegex(ValueError, "exit=9"): + self.runner.worker("test", run_dir) + self.assertEqual(12, self.runner.run_tokens) + + def test_unknown_previous_writer_is_never_replayed(self): + self.runner.state["state"] = "implementing" + with patch.object(self.runner, "worker") as worker: + self.assertEqual(3, self.runner.run(max_cycles=1)) + worker.assert_not_called() + self.assertEqual("needs_reconcile", self.runner.state["state"]) + + def test_timeout_kills_descendants_before_late_publication(self): + child = self.file("late.py", "import time\nfrom pathlib import Path\ntime.sleep(1)\nPath('late-result').write_text('wrong')\n") + parent = self.file("hang.py", f"import subprocess, sys, time\nsubprocess.Popen([sys.executable, {str(child)!r}])\ntime.sleep(30)\n") + self.runner.checkpoint("validating") + with contextlib.redirect_stdout(io.StringIO()): + result = self.runner.run_process([sys.executable, str(parent)], self.root, self.runner.directory / "timeout.log", 0.1) + self.assertTrue(result["timedOut"]) + time.sleep(1.1) + self.assertFalse((self.root / "late-result").exists()) + + def test_dirty_user_file_cannot_be_included_in_automatic_commit(self): + self.policy["autoCommit"] = True + write_json(self.runner.directory / "baseline.json", {"head": "none", "dirtyPaths": ["source.cpp"]}) + with self.assertRaisesRegex(ValueError, "pre-existing edits"): + self.runner.publish(self.context, ["source.cpp"]) + + def test_commit_excludes_unrelated_staged_changes(self): + def git(*args): + return subprocess.check_output(["git", *args], cwd=self.root, stderr=subprocess.DEVNULL, text=True).strip() + git("init", "-b", "main") + git("config", "user.name", "Supervisor Test") + git("config", "user.email", "supervisor@example.invalid") + self.file("user.txt", "original") + git("add", ".") + git("commit", "-m", "fixture") + self.file("user.txt", "user staged edit") + git("add", "user.txt") + self.runner.remember_baseline() + self.file("source.cpp", "verified implementation") + self.policy["autoCommit"] = True + self.assertTrue(self.runner.publish(self.context, ["source.cpp"])) + self.assertEqual("source.cpp", git("diff-tree", "--no-commit-id", "--name-only", "-r", "HEAD")) + self.assertEqual("user.txt", git("diff", "--cached", "--name-only")) + self.assertEqual("user staged edit", (self.root / "user.txt").read_text()) + + def test_daemon_lease_handoff_keeps_single_owner(self): + lock = self.root / "daemon.lock" + module_dir = str(Path(__file__).parent) + with Lease(lock) as lease: + fd = lease.stream.fileno() + code = f"from pathlib import Path\nimport time\nfrom wbv2_autopilot import Lease\nwith Lease(Path({str(lock)!r}), {fd}):\n print('owned', flush=True)\n time.sleep(0.4)\n" + child = subprocess.Popen([sys.executable, "-c", code], stdout=subprocess.PIPE, text=True, pass_fds=(fd,), env={**os.environ, "PYTHONPATH": module_dir}) + lease.transferred = True + try: + self.assertEqual("owned", child.stdout.readline().strip()) + with self.assertRaises(RuntimeError): + with Lease(lock): + pass + self.assertEqual(0, child.wait(timeout=3)) + finally: + if child.poll() is None: + child.kill() + child.wait() + child.stdout.close() + with Lease(lock): + pass + + def test_legacy_preflight_is_read_only_and_rejects_incomplete_terminal(self): + repo = Path(__file__).resolve().parents[1] + for name in ("run-wbv2-scheduler.mjs", "wbv2-failure-ledger.mjs"): + self.file("tools/web/" + name, (repo / "tools/web" / name).read_text()) + self.file("tools/web/check-task-context.mjs", "process.exit(0);\n") + write_json(self.root / "tests/golden/WBV2/task-index.json", {"activeTask": None, "entries": {self.task: {}}}) + write_json(self.root / f"tests/golden/{self.task}/manifest.json", {"task": self.task, "status": "in_progress", "nextTask": None}) + checkpoint = self.file("tests/golden/WBV2/continuous-scheduler.json", '{"state":"sentinel"}\n') + before = checkpoint.read_bytes() + result = subprocess.run(["node", "tools/web/run-wbv2-scheduler.mjs", "--preflight-only"], cwd=self.root, capture_output=True, text=True, timeout=10) + self.assertEqual(2, result.returncode, result.stderr) + self.assertIn("implementation_entrypoint_missing", result.stdout) + self.assertEqual(before, checkpoint.read_bytes()) + self.assertFalse((self.root / "tests/golden/WBV2/continuous-scheduler.lock").exists()) + + def test_time_labels_are_beijing_minutes(self): + self.assertEqual("2026-09-08 10:10", minute_label("2026-09-08T02:10:59.999Z")) + self.assertEqual({"updatedAt": "2026-09-08 10:10", "durationSeconds": 0.04}, display_times({"updatedAt": "2026-09-08T02:10:59+00:00", "durationSeconds": 0.04})) + + def test_quick_command_has_no_one_second_polling_floor(self): + script = self.file("quick.py", "import time\ntime.sleep(0.03)\n") + self.policy.update(heartbeatSeconds=5, monitorPollSeconds=0.25) + with patch.object(self.runner, "checkpoint", wraps=self.runner.checkpoint) as checkpoints, contextlib.redirect_stdout(io.StringIO()): + result = self.runner.run_process([sys.executable, str(script)], self.root, self.runner.directory / "quick.log", 5) + self.assertLess(result["durationSeconds"], 0.9) + self.assertEqual(2, checkpoints.call_count) + + def model_script(self, source): + script = self.file("model_fixture.py", source) + self.policy.update(monitorPollSeconds=0.02, modelStartTimeoutSeconds=0.15, modelIdleTimeoutSeconds=0.15) + with contextlib.redirect_stdout(io.StringIO()): + return self.runner.run_process([sys.executable, str(script)], self.root, self.runner.directory / "model.log", 5, monitor_worker=True, phase="model_request") + + def test_provider_error_before_actions_releases_process_early(self): + result = self.model_script("import time\nprint('{\"type\":\"turn.started\"}', flush=True)\nprint('{\"type\":\"error\",\"message\":\"Concurrency limit exceeded\"}', flush=True)\ntime.sleep(10)\n") + self.assertEqual("provider_unavailable", result["providerAbort"]) + self.assertTrue(result["workerTrace"]["safeToRetry"]) + self.assertLess(result["durationSeconds"], 1) + + def test_model_start_without_progress_is_bounded(self): + result = self.model_script("import time\nprint('{\"type\":\"turn.started\"}', flush=True)\ntime.sleep(10)\n") + self.assertEqual("model_start_timeout", result["providerAbort"]) + self.assertTrue(result["workerTrace"]["safeToRetry"]) + + def test_stalled_model_after_actions_requires_reconciliation(self): + result = self.model_script("import time\nprint('{\"type\":\"turn.started\"}', flush=True)\nprint('{\"type\":\"item.completed\",\"item\":{\"id\":\"edit\",\"type\":\"file_change\"}}', flush=True)\ntime.sleep(10)\n") + self.assertEqual("model_idle_timeout", result["providerAbort"]) + self.assertFalse(result["workerTrace"]["safeToRetry"]) + + def test_active_tool_is_not_mistaken_for_model_idle(self): + result = self.model_script("import time\nprint('{\"type\":\"turn.started\"}', flush=True)\nprint('{\"type\":\"item.started\",\"item\":{\"id\":\"build\",\"type\":\"command_execution\",\"command\":\"cmake --build build\"}}', flush=True)\ntime.sleep(0.25)\nprint('{\"type\":\"item.completed\",\"item\":{\"id\":\"build\",\"type\":\"command_execution\",\"exit_code\":0}}', flush=True)\n") + self.assertIsNone(result["providerAbort"]) + self.assertEqual(0, result["exitCode"]) + self.assertEqual("build", result["workerTrace"]["items"][0]["phase"]) + + def test_provider_failures_have_separate_bounded_budget(self): + with patch.object(self.runner, "worker", side_effect=ProviderUnavailable("rate limit")), contextlib.redirect_stdout(io.StringIO()): + for failure in range(1, 5): + self.assertFalse(self.runner.attempt(self.context, self.job)) + record = self.runner.state["jobs"][self.job["id"]] + self.assertEqual(0, record["attempts"]) + self.assertEqual(failure, record["providerFailures"]) + self.assertEqual("provider_blocked", self.runner.state["state"]) + + def test_provider_failure_with_source_changes_is_not_retried(self): + def changed(*args): + self.file("source.cpp", "unexpected change") + raise ProviderUnavailable("overload") + with patch.object(self.runner, "worker", side_effect=changed), contextlib.redirect_stdout(io.StringIO()): + self.assertFalse(self.runner.attempt(self.context, self.job)) + self.assertEqual("needs_reconcile", self.runner.state["state"]) + + def test_jsonl_partial_reads_and_nested_tool_timing(self): + trace = WorkerTrace() + p = self.file("events.jsonl", '{"type":"turn.star') + trace.read(p, 0.1) + self.assertFalse(trace.safe_to_retry) + with p.open("a") as stream: + stream.write('ted"}\n') + trace.read(p, 0.2) + self.assertTrue(trace.safe_to_retry) + trace.feed({"type": "item.started", "item": {"id": "read", "type": "command_execution", "command": "rg pattern source.cpp"}}, 1) + trace.feed({"type": "item.completed", "item": {"id": "read", "type": "command_execution", "exit_code": 0}}, 1.4) + self.assertAlmostEqual(0.4, trace.items[0]["durationSeconds"]) + self.assertEqual("reading", trace.items[0]["phase"]) + event = {"event": "process.finished", "argv": ["codex", "exec"], "log": "model.log", "startedAt": "2026-09-08T02:10:00+00:00", "finishedAt": "2026-09-08T02:10:02+00:00", "durationSeconds": 2, "workerTrace": trace.snapshot(2)} + self.file(CONTROL + "/events.jsonl", json.dumps(event) + "\n") + report = timing_report(self.runner.directory) + self.assertAlmostEqual(2 / 60, report["totalMeasuredMinutes"], places=4) + self.assertEqual("2026-09-08 10:10", report["steps"][0]["start"]) + + def test_business_routes_and_native_source_are_mandatory(self): + run_dir = self.runner.directory / "runs/contract" + result = self.ready_result(run_dir) + result["routeIds"] = [] + with self.assertRaisesRegex(ValueError, "business workflow"): + self.runner.validate_result(result, run_dir) + result["routeIds"] = ["operator:TEST"] + result["sourceReferences"] = ["source.cpp"] + with self.assertRaisesRegex(ValueError, "native Blender source"): + self.runner.validate_result(result, run_dir) + + +if __name__ == "__main__": + unittest.main() diff --git a/my-tools/wbv2_autopilot.py b/my-tools/wbv2_autopilot.py new file mode 100644 index 000000000..d5b6049c9 --- /dev/null +++ b/my-tools/wbv2_autopilot.py @@ -0,0 +1,946 @@ +#!/usr/bin/env python3 +"""Persistent, independently verified Blender Web migration supervisor.""" +from __future__ import annotations + +import argparse +from contextlib import contextmanager +import fcntl +import hashlib +import json +import os +import re +import shutil +import signal +import subprocess +import sys +import time +import uuid +from datetime import datetime, timezone +from pathlib import Path + +from wbv2_timing import WorkerTrace, command_phase, display_times, format_report, minute_label, timing_report + +ROOT = Path(__file__).resolve().parents[1] +CONTROL = "tests/golden/WBV2/autopilot" +POLICY = "my-tools/wbv2_autopilot_policy.json" +REQUIRED = {"source_build", "typecheck", "lint", "chromium", "positive", "negative", "undo_redo", "save_reopen", "determinism"} +ACTIVE = {"implementing", "validating", "finalizing", "committing", "committed", "pushing", "pushed"} + + +class ProviderUnavailable(ValueError): + """No agent action started before a bounded provider failure.""" + + +def now(): + return datetime.now(timezone.utc).isoformat() + + +def read_json(path, default=None): + try: + return json.loads(path.read_text(encoding="utf-8")) + except FileNotFoundError: + if default is not None: + return default + raise + + +def write_json(path, value): + path.parent.mkdir(parents=True, exist_ok=True) + temporary = path.with_name(path.name + f".tmp-{os.getpid()}") + with temporary.open("w", encoding="utf-8") as stream: + json.dump(value, stream, ensure_ascii=True, indent=2) + stream.write("\n") + stream.flush() + os.fsync(stream.fileno()) + temporary.replace(path) + + +def sha(path): + if not path.is_file(): + return None + with path.open("rb") as stream: + return hashlib.file_digest(stream, "sha256").hexdigest() + + +def contained(root, relative): + if not isinstance(relative, str) or not relative or Path(relative).is_absolute() or ".." in Path(relative).parts: + raise ValueError(f"invalid relative path: {relative!r}") + result = (root / relative).resolve() + if not result.is_relative_to(root.resolve()): + raise ValueError(f"path escapes repository: {relative}") + return result + + +def alive(pid): + if not isinstance(pid, int) or pid <= 0: + return False + try: + os.kill(pid, 0) + return True + except ProcessLookupError: + return False + except PermissionError: + return True + + +def identity(pid): + try: + return Path(f"/proc/{pid}/stat").read_text().rsplit(")", 1)[1].split()[19] + except (OSError, IndexError): + return None + + +class Lease: + def __init__(self, path, inherited=None): + self.path = path + self.inherited = inherited + self.transferred = False + + def __enter__(self): + self.path.parent.mkdir(parents=True, exist_ok=True) + self.stream = os.fdopen(self.inherited, "a+") if self.inherited is not None else self.path.open("a+") + if os.fstat(self.stream.fileno()).st_ino != self.path.stat().st_ino: + self.stream.close() + raise RuntimeError("inherited lease does not match the owner lock") + try: + fcntl.flock(self.stream, fcntl.LOCK_EX | fcntl.LOCK_NB) + except BlockingIOError: + self.stream.close() + raise RuntimeError("another Python autopilot owns the project") from None + self.stream.seek(0) + self.stream.truncate() + json.dump({"pid": os.getpid(), "identity": identity(os.getpid()), "startedAt": now()}, self.stream) + self.stream.flush() + return self + + def __exit__(self, *_): + # Never unlink a flock inode while another process can hold it open. + if not self.transferred: + fcntl.flock(self.stream, fcntl.LOCK_UN) + self.stream.close() + + +class ProjectFence: + """Share the existing scheduler's exclusive marker with Python runs.""" + def __init__(self, root): + self.directory = root / "tests/golden/WBV2" + self.path = self.directory / "continuous-scheduler.lock" + + def __enter__(self): + self.directory.mkdir(parents=True, exist_ok=True) + for name in ("continuous-scheduler.lock", "continuous-guardian.lock", "continuous-supervisor.lock", "web-product-migration.lock"): + owner = read_json(self.directory / name, {}) + if alive(owner.get("pid")): + raise RuntimeError(f"another project runner is active: {name}") + try: + with self.path.open("x", encoding="utf-8") as stream: + json.dump({"pid": os.getpid(), "identity": identity(os.getpid()), "runtime": "python-autopilot", "startedAt": now()}, stream) + except FileExistsError: + raise RuntimeError("stale scheduler lock requires reconciliation before Python can claim it") from None + return self + + def __exit__(self, *_): + owner = read_json(self.path, {}) + if owner.get("pid") == os.getpid() and owner.get("runtime") == "python-autopilot": + self.path.unlink() + + +def queue_context(root): + queue = (root / "docs/EXECUTION_QUEUE.md").read_text(encoding="utf-8") + task = re.search(r"\| 当前任务 \| `([^`]+)` \|", queue) + parent = re.search(r"\| parent manifest \| `([^`]+)` \|", queue) + if not task or not parent or not re.fullmatch(r"WBV2-P\d+-\d+", task[1]): + raise ValueError("authoritative queue pointer is malformed") + manifest = read_json(contained(root, parent[1])) + if manifest.get("status") != "done" or manifest.get("nextTask") != task[1]: + raise ValueError("parent manifest does not authorize the current task") + card = f"docs/tasks/{task[1]}.md" + if not (root / card).is_file(): + raise ValueError("current task card is missing") + return {"task": task[1], "parentManifest": parent[1], "card": card, "parentSha256": sha(root / parent[1])} + + +def manifest_proof(root, task): + manifest = read_json(contained(root, f"tests/golden/{task}/manifest.json"), {}) + reasons = [] + if manifest.get("task") != task or manifest.get("status") != "done": + reasons.append("task_not_done") + if manifest.get("verificationDeferred") or manifest.get("acceptanceComplete") is not True: + reasons.append("runtime_acceptance_not_complete") + artifacts = manifest.get("artifacts", {}) + if not isinstance(artifacts, dict) or not artifacts: + reasons.append("artifacts_missing") + else: + for name, item in artifacts.items(): + try: + if not item.get("sha256") or sha(contained(root, item["path"])) != item["sha256"]: + reasons.append(f"artifact_drift:{name}") + except (KeyError, ValueError, AttributeError): + reasons.append(f"artifact_invalid:{name}") + return {"ok": not reasons, "reasons": reasons, "nextTask": manifest.get("nextTask")} + + +def inventory_proof(root): + inventory = read_json(root / "tests/golden/WBV2/dynamic-inventory.json") + units = inventory.get("units", []) + unverified = sum(unit.get("coverageStatus") != "VERIFIED" for unit in units) + invalid, checked = 0, {} + for unit in units: + if unit.get("coverageStatus") != "VERIFIED": + continue + matches = True + for key in ("evidenceManifest", "productionEvidence"): + item = unit.get("coverage", {}).get(key, {}) + try: + signature = (item["path"], item["sha256"]) + if signature not in checked: + checked[signature] = bool(item["sha256"]) and sha(contained(root, item["path"])) == item["sha256"] + matches = matches and checked[signature] + except (KeyError, ValueError): + matches = False + invalid += not matches + return {"ok": bool(units) and unverified == 0 and invalid == 0, "unitCount": len(units), "recordedVerified": len(units) - unverified, "unverifiedUnits": unverified, "unitsWithInvalidReferences": invalid} + + +def result_schema(): + strings = {"type": "array", "items": {"type": "string"}} + def obj(properties): + return {"type": "object", "additionalProperties": False, "required": list(properties), "properties": properties} + check = obj({"id": {"type": "string"}, "kinds": strings, "argv": strings, "cwd": {"type": "string"}}) + case = obj({"id": {"type": "string"}, "kind": {"type": "string"}, "checkId": {"type": "string"}, "receipt": {"type": "string"}, "unitIds": strings}) + return obj({"status": {"type": "string", "enum": ["ready", "blocked"]}, "summary": {"type": "string"}, "workflow": {"type": "string"}, "routeIds": strings, "sourceReferences": strings, "changedFiles": strings, "sourceUnits": strings, "dependencies": strings, "artifacts": strings, "checks": {"type": "array", "items": check}, "cases": {"type": "array", "items": case}}) + + +def validate_command(root, argv, cwd): + if not argv or not all(isinstance(v, str) and v and "\0" not in v for v in argv): + raise ValueError("command must be an argv array") + directory = root if cwd == "." else contained(root, cwd) + if not directory.is_dir(): + raise ValueError("command cwd does not exist") + if argv[0] not in {"node", "python3", "npm", "cmake", "ninja", "ctest", "git"}: + raise ValueError("unsupported validation executable") + if any(arg in {"-e", "--eval", "-c", "--command", "--input-type=module"} for arg in argv[1:]): + raise ValueError("inline code is not a validation entrypoint") + if any(re.search(r"firefox|webkit", arg, re.I) for arg in argv): + raise ValueError("only Chromium is permitted") + if argv[0] == "git" and argv != ["git", "diff", "--check"]: + raise ValueError("validation cannot change Git state") + if argv[0] in {"node", "python3"}: + scripts = [arg for arg in argv[1:] if arg.endswith((".mjs", ".js", ".py"))] + if not scripts or any(not (directory / p).resolve().is_relative_to(root) or not (directory / p).is_file() for p in scripts): + raise ValueError("a concrete repository validation script is required") + if argv[0] == "npm" and "run" not in argv: + raise ValueError("only repository npm run scripts are permitted") + return argv, directory + + +class Autopilot: + def __init__(self, root=ROOT, policy=None): + self.root = root.resolve() + self.directory = self.root / CONTROL + self.policy = policy or read_json(self.root / POLICY) + if self.policy.get("sourceFirst") is not True: + raise ValueError("source-first business workflow policy is mandatory") + if not REQUIRED.issubset(self.policy.get("requiredChecks", [])): + raise ValueError("policy cannot omit mandatory behavioral gates") + for key in ("workerTimeoutSeconds", "checkTimeoutSeconds", "heartbeatSeconds", "maxAttempts", "maxTokensPerRun", "maxLogBytes", "maxBuildJobs", "monitorPollSeconds", "modelStartTimeoutSeconds", "modelIdleTimeoutSeconds", "providerBackoffSeconds", "providerMaxBackoffSeconds", "maxProviderFailures"): + if not isinstance(self.policy.get(key), (float, int)) or self.policy[key] <= 0: + raise ValueError(f"invalid positive policy limit: {key}") + self.state_path = self.directory / "state.json" + self.state = read_json(self.state_path, {"schemaVersion": 1, "state": "idle", "jobs": {}, "tokensUsed": 0}) + self.stop_requested = False + self.child = None + self.run_tokens = 0 + + def checkpoint(self, state, **values): + self.state.update(state=state, updatedAt=now(), pid=os.getpid(), identity=identity(os.getpid()), **values) + write_json(self.state_path, self.state) + write_json(self.root / "tests/golden/WBV2/web-product-migration-status.json", {"schemaVersion": 2, "pid": os.getpid(), "status": state, "updatedAt": now(), "activeTask": self.state.get("activeJob"), "checkpoint": str(self.state_path.relative_to(self.root)), "verifiedJobs": sum(j.get("state") == "verified" for j in self.state["jobs"].values()), "reason": self.state.get("reason")}) + + def event(self, kind, **values): + self.directory.mkdir(parents=True, exist_ok=True) + record = {"time": now(), "event": kind, **values} + line = json.dumps(record, ensure_ascii=True) + with (self.directory / "events.jsonl").open("a", encoding="utf-8") as stream: + stream.write(line + "\n") + print(json.dumps(display_times({**record, "time": minute_label(record["time"])}), ensure_ascii=True), flush=True) + + @contextmanager + def timed(self, phase): + started, wall = time.monotonic(), now() + try: + yield + finally: + self.event("timing.span", phase=phase, startedAt=wall, finishedAt=now(), durationSeconds=round(time.monotonic() - started, 6)) + + def request_stop(self, *_): + self.stop_requested = True + if self.child and self.child.poll() is None: + try: + os.killpg(self.child.pid, signal.SIGTERM) + except ProcessLookupError: + pass + + def run_process(self, argv, directory, log, timeout, stdin=None, env=None, monitor_worker=False, phase=None): + log.parent.mkdir(parents=True, exist_ok=True) + started = time.monotonic() + phase = phase or command_phase(argv) + result = {"argv": argv, "cwd": str(directory.relative_to(self.root)), "phase": phase, "startedAt": now(), "log": str(log.relative_to(self.root))} + trace = WorkerTrace() if monitor_worker else None + provider_abort = None + next_heartbeat = started + self.policy["heartbeatSeconds"] + last_provider_error = None + interrupted = timed_out = log_limit = False + self.event("process.started", **result) + with log.open("wb") as output: + self.child = subprocess.Popen(argv, cwd=directory, env={**os.environ, **(env or {})}, stdin=subprocess.PIPE if stdin is not None else subprocess.DEVNULL, stdout=output, stderr=subprocess.STDOUT, start_new_session=True) + self.checkpoint(self.state["state"], childPid=self.child.pid, childIdentity=identity(self.child.pid), currentProcess={**result, "status": "running", "elapsedSeconds": 0, "phase": "provider_wait" if trace else phase}) + if stdin is not None: + try: + self.child.stdin.write(stdin.encode()) + self.child.stdin.close() + except BrokenPipeError: + pass + while self.child.poll() is None: + elapsed = time.monotonic() - started + if trace: + trace.read(log, elapsed) + if trace.provider_error and not trace.actions_seen: + provider_abort = "provider_unavailable" + elif not trace.actions_seen and elapsed >= self.policy.get("modelStartTimeoutSeconds", 60): + provider_abort = "model_start_timeout" + elif trace.actions_seen and not trace.active_items and elapsed - trace.last_progress >= self.policy.get("modelIdleTimeoutSeconds", 180): + provider_abort = "model_idle_timeout" + interrupted = self.stop_requested or (self.directory / "pause.request").exists() + timed_out = elapsed > timeout + log_limit = log.stat().st_size > self.policy["maxLogBytes"] + if interrupted or timed_out or log_limit or provider_abort: + try: + os.killpg(self.child.pid, signal.SIGTERM) + self.child.wait(timeout=5) + except ProcessLookupError: + pass + except subprocess.TimeoutExpired: + os.killpg(self.child.pid, signal.SIGKILL) + self.child.wait() + break + changed_error = trace and trace.provider_error != last_provider_error + if time.monotonic() >= next_heartbeat or changed_error: + current = {**result, "status": "running", "elapsedSeconds": round(elapsed, 3)} + if trace: + current.update(phase="provider_wait" if not trace.actions_seen else "agent_work", providerError=trace.provider_error, firstActionSeconds=trace.first_action, idleSeconds=round(elapsed - trace.last_progress, 3), activeItems=list(trace.active_items.values())) + last_provider_error = trace.provider_error + self.checkpoint(self.state["state"], heartbeatAt=now(), currentProcess=current) + next_heartbeat = time.monotonic() + self.policy["heartbeatSeconds"] + wait_for = max(0.001, min(self.policy.get("monitorPollSeconds", 0.25), next_heartbeat - time.monotonic(), timeout - elapsed)) + try: + self.child.wait(timeout=wait_for) + except subprocess.TimeoutExpired: + pass + code = self.child.wait() + interrupted = interrupted or self.stop_requested or (self.directory / "pause.request").exists() + if trace: + trace.read(log, time.monotonic() - started) + try: + os.killpg(self.child.pid, signal.SIGTERM) + time.sleep(0.1) + os.killpg(self.child.pid, signal.SIGKILL) + except ProcessLookupError: + pass + self.child = None + elapsed = time.monotonic() - started + result.update(exitCode=code, durationSeconds=round(elapsed, 6), interrupted=interrupted, timedOut=timed_out, logLimit=log_limit, providerAbort=provider_abort, logSha256=sha(log), finishedAt=now()) + if trace: + result["workerTrace"] = trace.snapshot(elapsed) + self.state.pop("childPid", None) + self.state.pop("childIdentity", None) + write_json(log.with_suffix(log.suffix + ".process.json"), result) + self.event("process.finished", **result) + self.checkpoint(self.state["state"], currentProcess={"phase": phase, "startedAt": result["startedAt"], "finishedAt": result["finishedAt"], "status": "finished", "durationSeconds": result["durationSeconds"], "providerAbort": provider_abort}) + return result + + def protected_hashes(self, context): + files = ["docs/EXECUTION_QUEUE.md", "nextTask.md", context["parentManifest"], "tests/golden/WBV2/web-product-backlog.json", "tests/golden/WBV2/dynamic-inventory.json", "tests/golden/WBV2/task-index.json", "tests/golden/WBV2-P0-002/parity-map.json", "my-tools/wbv2_autopilot.py", POLICY, f"tests/golden/{context['task']}/manifest.json"] + inventory = read_json(self.root / "tests/golden/WBV2/dynamic-inventory.json", {}) + for unit in inventory.get("units", []): + for key in ("evidenceManifest", "productionEvidence"): + artifact = unit.get("coverage", {}).get(key) + if artifact: + files.append(artifact["path"]) + files.append("my-tools/wbv2_timing.py") + with self.timed("evidence_hashing"): + return {p: sha(self.root / p) for p in sorted(set(files))} + + def jobs(self, context): + backlog = read_json(self.root / "tests/golden/WBV2/web-product-backlog.json", {}) + jobs = [dict(j) for j in backlog.get("tasks", [])] if backlog.get("queueTask") == context["task"] else [{"id": context["task"], "title": "Implement the current source-backed module", "ownedPaths": [], "implementation": "Follow the current module card and its source/case contract."}] + priority = self.policy.get("priority", []) + jobs.sort(key=lambda j: priority.index(j["id"]) if j["id"] in priority else len(priority)) + for job in jobs: + if not re.fullmatch(r"[A-Z0-9_-]+", job["id"]): + raise ValueError("unsafe job identifier") + job["queueTask"] = context["task"] + return jobs + + def receipt_valid(self, record): + if record.get("state") != "verified" or not record.get("receipt"): + return False + try: + receipt = read_json(contained(self.root, record["receipt"])) + if sha(self.root / record["receipt"]) != record.get("receiptSha256"): + return False + return all(sha(contained(self.root, p)) == digest for p, digest in receipt["inputs"].items()) and all(sha(contained(self.root, a["path"])) == a["sha256"] for a in receipt["artifacts"]) + except (OSError, KeyError, ValueError): + return False + + def choose_job(self, jobs): + # Complete untouched workflows before revisiting shared-file changes. + for job in jobs: + if self.state["jobs"].get(job["id"], {}).get("state") != "verified": + return job + return next((job for job in jobs if not self.receipt_valid(self.state["jobs"][job["id"]])), None) + + def worker_prompt(self, context, job, run_dir, previous): + receipt_dir = str((run_dir / "cases").relative_to(self.root)) + return f"""Implement one bounded Blender Web workflow in {self.root}. +Queue: {json.dumps(context, ensure_ascii=True)} +Workflow inside this task: {json.dumps(job, ensure_ascii=True)} +Previous attempt: {json.dumps(previous, ensure_ascii=True)[:4000]} +Known findings: {json.dumps(self.policy.get('knownFindings', []), ensure_ascii=True)} + +Follow AGENTS.md: read the queue, print-task-context, check-task-context, then only named owned paths and bounded source searches. +Drive this task by its business module, user workflow and concrete function routes, then the exact source/operator case matrix. +FIRST search the supplied Blender 5.2 sources and task-scoped related references to resolve behavior before editing the Web implementation. +Use node tools/web/search-wbv2-batch-source.mjs --unit --pattern to read bounded native source locations. +Blender 5.2 source/Main is authoritative. Never simulate Blender in JS or count route classification, timing, builds or bookkeeping as completed behavior. +Preserve dirty files. Reconcile previous edits before changing code. Never replay an unknown generator or external write. +Implement production code and executable focused tests, adding only directly related helpers/tests. +Do not modify queue, parent manifests, nextTask.md, backlog, historical evidence, source inventory or autopilot control files. +Do not commit, push, SSH, deploy, install services, start agents or change the live website. +Do not run expensive validation yourself: the independent supervisor executes your checks after your process exits successfully. +Return ready only when implementation and runnable tests are prepared; ready is NOT completion. +Checks use argv arrays and repo-relative cwd, with no shell or inline code and only Chromium. +Required check kinds: {', '.join(sorted(REQUIRED))}. Reuse existing build/test entrypoints; one command may cover multiple kinds. +Tests must prove positive Main mutation or exact Main reader, negative no-mutation, undo/redo, save/reopen and determinism. +Declare cases for positive, negative, undo_redo, save_reopen and determinism, bound to checkId and exact source inventory unitIds. +Tests must write fresh case receipts under {receipt_dir}/ at validation time using WBV2_RECEIPT_DIR. Do NOT write these receipts now. +Case JSON: status=PASS, runtime=CHROMIUM_WEBENGINE or BLENDER_NATIVE, caseId, kind, unitIds, observations, artifacts=[{{path,sha256}}]. +observations use SHA-256 of actual canonical native Main snapshots: positive before/after differ, or reader expected/actual equal with reader=true; negative before/after equal; undo_redo before/after/undo/redo prove reversal; save_reopen saved/reopened equal; determinism first/second equal. At least one case must run in Chromium. +Use actual native/Chromium receipts, screenshots, .blend or WASM artifacts. Test assertions must verify behavior, not static markers. +List source/protocol/test/fixture/build dependencies for hash invalidation and compiled WASM/native paths in artifacts. +Return workflow (the concrete user workflow), routeIds (exact current route catalog IDs) and sourceReferences (native Blender files actually used). +sourceUnits must be existing dynamic inventory IDs. Do not claim verified coverage; the supervisor checks and hashes results. +Return blocked with a concrete reason if prerequisites cannot be established. +""" + + def worker(self, prompt, run_dir): + schema_path, output_path = run_dir / "result.schema.json", run_dir / "worker-result.json" + write_json(schema_path, result_schema()) + command = ["codex", "exec", "--sandbox", self.policy["sandbox"], "-c", 'approval_policy="never"', "--ephemeral", "--cd", str(self.root), "--json", "--output-schema", str(schema_path), "--output-last-message", str(output_path), "-"] + proc = self.run_process(command, self.root, run_dir / "worker.jsonl", self.policy["workerTimeoutSeconds"], stdin=prompt, monitor_worker=True, phase="handoff_model" if self.state["state"] == "finalizing" else "model_request") + completed = False + for line in (run_dir / "worker.jsonl").read_text(encoding="utf-8", errors="replace").splitlines(): + try: + event = json.loads(line) + except json.JSONDecodeError: + continue + if event.get("type") == "turn.completed": + completed = True + usage = event.get("usage", {}) + tokens = int(usage.get("input_tokens", 0)) + int(usage.get("output_tokens", 0)) + self.run_tokens += tokens + self.state["tokensUsed"] = self.state.get("tokensUsed", 0) + tokens + if proc["interrupted"] or proc["timedOut"] or proc["logLimit"]: + self.checkpoint("needs_reconcile", reason="worker interrupted; inspect edits and process receipt before resuming") + raise InterruptedError(self.state["reason"]) + trace = proc.get("workerTrace", {}) + if proc.get("providerAbort") or trace.get("providerError"): + if trace.get("safeToRetry"): + raise ProviderUnavailable(trace.get("providerError") or proc["providerAbort"]) + if proc.get("providerAbort"): + raise InterruptedError("model stalled after actions or unrecognized output; inspect the bounded trace before retry") + if proc["exitCode"] != 0 or not completed: + raise ValueError(f"worker failed: exit={proc['exitCode']}, turnCompleted={completed}") + return read_json(output_path) + + def validate_result(self, result, run_dir): + if result.get("status") != "ready": + raise ValueError(result.get("summary", "worker reported blocked")) + known = {u["id"] for u in read_json(self.root / "tests/golden/WBV2/dynamic-inventory.json")["units"]} + units = set(result.get("sourceUnits", [])) + if not units or not units.issubset(known): + raise ValueError("missing or unknown source unit bindings") + catalog = read_json(self.root / "web/app/src/capabilities/blender-feature-route-catalog.json") + route_ids = set(result.get("routeIds", [])) + if not result.get("workflow", "").strip() or not route_ids or not route_ids.issubset({entry["id"] for entry in catalog["entries"]}) or units != route_ids: + raise ValueError("a concrete business workflow and source-bound function routes are required") + references = result.get("sourceReferences", []) + if not references or any(not p.startswith("blender-5.2.0/source/blender/") or not contained(self.root, p).is_file() for p in references): + raise ValueError("native Blender source references are required before Web implementation") + kinds, ids = set(), {} + for check in result.get("checks", []): + if not re.fullmatch(r"[A-Za-z0-9_-]+", check["id"]) or check["id"] in ids: + raise ValueError("check IDs must be unique and path-safe") + ids[check["id"]] = check + kinds.update(check["kinds"]) + validate_command(self.root, check["argv"], check["cwd"]) + if not REQUIRED.issubset(kinds): + raise ValueError(f"missing validation kinds: {sorted(REQUIRED - kinds)}") + case_kinds, case_ids, paths, covered = set(), set(), set(), set() + positive_units = set() + for case in result.get("cases", []): + destination = contained(self.root, case["receipt"]) + if not destination.is_relative_to(run_dir / "cases") or destination.exists(): + raise ValueError("behavioral receipts must be fresh validation output in this attempt") + if case["checkId"] not in ids or case["kind"] not in ids[case["checkId"]]["kinds"] or case["id"] in case_ids or str(destination) in paths: + raise ValueError("invalid or duplicate case/check binding") + case_ids.add(case["id"]) + paths.add(str(destination)) + case_kinds.add(case["kind"]) + if not case["unitIds"] or not set(case["unitIds"]).issubset(units): + raise ValueError("invalid source-unit case binding") + covered.update(case["unitIds"]) + if case["kind"] == "positive": + positive_units.update(case["unitIds"]) + if not {"positive", "negative", "undo_redo", "save_reopen", "determinism"}.issubset(case_kinds) or covered != units or positive_units != units: + raise ValueError("incomplete behavioral case matrix") + for p in result.get("changedFiles", []) + result.get("dependencies", []) + result.get("artifacts", []): + contained(self.root, p) + if not any(p.endswith((".wasm", "/blender", "/web_engine")) for p in result.get("artifacts", [])): + raise ValueError("a compiled Blender/WASM artifact is required") + + def verify_cases(self, result): + artifacts = [] + chromium = False + for case in result["cases"]: + p = contained(self.root, case["receipt"]) + receipt = read_json(p) + if receipt.get("status") != "PASS" or receipt.get("runtime") not in {"CHROMIUM_WEBENGINE", "BLENDER_NATIVE"}: + raise ValueError(f"runtime case failed: {case['id']}") + if receipt.get("caseId") != case["id"] or receipt.get("kind") != case["kind"] or set(receipt.get("unitIds", [])) != set(case["unitIds"]): + raise ValueError("runtime receipt does not match the requested case") + chromium = chromium or receipt["runtime"] == "CHROMIUM_WEBENGINE" + observations = receipt.get("observations", {}) + def hashes(*keys): + values = [observations.get(key, "") for key in keys] + if not all(isinstance(v, str) and re.fullmatch(r"[a-f0-9]{64}", v) for v in values): + raise ValueError(f"missing native state hashes: {case['id']}") + return values + kind = case["kind"] + if kind == "positive" and observations.get("reader"): + left, right = hashes("expected", "actual") + valid = left == right + elif kind in {"positive", "negative"}: + left, right = hashes("before", "after") + valid = (left != right) if kind == "positive" else (left == right) + elif kind == "undo_redo": + before, after, undo, redo = hashes("before", "after", "undo", "redo") + valid = before != after and before == undo and after == redo + elif kind == "save_reopen": + saved, reopened = hashes("saved", "reopened") + valid = saved == reopened + elif kind == "determinism": + first, second = hashes("first", "second") + valid = first == second + else: + valid = False + if not valid: + raise ValueError(f"native behavior assertion failed: {case['id']}") + if not receipt.get("artifacts"): + raise ValueError("runtime case has no production artifacts") + for artifact in receipt["artifacts"]: + if not artifact.get("sha256") or sha(contained(self.root, artifact["path"])) != artifact["sha256"]: + raise ValueError(f"runtime artifact hash drift: {case['id']}") + artifacts.append(artifact) + artifacts.append({"path": case["receipt"], "sha256": sha(p)}) + if not chromium: + raise ValueError("no Chromium runtime case receipt") + return artifacts + + def attempt(self, context, job): + previous = self.state["jobs"].get(job["id"], {}) + count = int(previous.get("attempts", 0)) + 1 + run_dir = self.directory / "runs" / f"{job['id']}-{uuid.uuid4().hex[:12]}" + run_dir.mkdir(parents=True) + record = {"state": "implementing", "attempts": count, "providerFailures": previous.get("providerFailures", 0), "runDirectory": str(run_dir.relative_to(self.root))} + self.state["jobs"][job["id"]] = record + protected = self.protected_hashes(context) + with self.timed("source_fingerprint"): + owned_before = {p: sha(contained(self.root, p)) for p in job.get("ownedPaths", [])} + write_json(run_dir / "before-worker.json", {"protected": protected, "owned": owned_before}) + self.checkpoint("implementing", activeJob=job["id"], queue=context, reason=None) + try: + result = self.worker(self.worker_prompt(context, job, run_dir, previous), run_dir) + if self.protected_hashes(context) != protected: + raise InterruptedError("worker changed protected queue/evidence files") + self.validate_result(result, run_dir) + inputs = sorted(set(job.get("ownedPaths", []) + result["changedFiles"] + result["dependencies"] + result["sourceReferences"] + [context["card"], context["parentManifest"], POLICY])) + before = {p: sha(contained(self.root, p)) for p in inputs} + if any(value is None for value in before.values()): + raise ValueError("declared dependency does not exist") + record["state"] = "validating" + self.checkpoint("validating") + checks, cache = [], {} + env = {"WBV2_RECEIPT_DIR": str(run_dir / "cases"), "WBV2_DEPLOYED_ORIGIN": self.policy["origin"], "WEB_BUILD_JOBS": str(min(self.policy["maxBuildJobs"], 8)), "CMAKE_BUILD_PARALLEL_LEVEL": str(min(self.policy["maxBuildJobs"], 8))} + for check in result["checks"]: + argv, cwd = validate_command(self.root, check["argv"], check["cwd"]) + key = json.dumps([argv, str(cwd)]) + if key not in cache: + cache[key] = self.run_process(argv, cwd, run_dir / f"check-{check['id']}.log", self.policy["checkTimeoutSeconds"], env=env, phase="validation:" + "+".join(sorted(check["kinds"]))) + else: + self.event("check.reused", checkId=check["id"], originalLog=cache[key]["log"], avoidedSeconds=cache[key]["durationSeconds"]) + receipt = {**cache[key], "id": check["id"], "kinds": check["kinds"]} + checks.append(receipt) + if receipt["exitCode"] != 0 or receipt["interrupted"] or receipt["timedOut"] or receipt["logLimit"]: + raise ValueError(f"check {check['id']} failed: exit={receipt['exitCode']}, timeout={receipt['timedOut']}") + if self.protected_hashes(context) != protected or any(sha(self.root / p) != digest for p, digest in before.items()): + raise InterruptedError("source/protected evidence changed during validation") + artifacts = self.verify_cases(result) + for p in result["artifacts"]: + digest = sha(contained(self.root, p)) + if digest is None: + raise ValueError(f"compiled artifact missing: {p}") + artifacts.append({"path": p, "sha256": digest}) + for check in checks: + artifacts.append({"path": check["log"], "sha256": check["logSha256"]}) + receipt_path = run_dir / "verified-receipt.json" + write_json(receipt_path, {"schemaVersion": 1, "queueTask": context["task"], "job": job["id"], "workflow": result["workflow"], "routeIds": result["routeIds"], "sourceReferences": result["sourceReferences"], "status": "verified", "verifiedAt": now(), "sourceUnits": result["sourceUnits"], "inputs": before, "checks": checks, "artifacts": artifacts, "coverageIncrementClaimed": 0, "summary": result["summary"]}) + record.update(state="verified", receipt=str(receipt_path.relative_to(self.root)), receiptSha256=sha(receipt_path), changedFiles=result["changedFiles"], attempts=0, providerFailures=0) + self.checkpoint("ready", activeJob=None) + self.event("job.verified", job=job["id"], receipt=record["receipt"]) + return True + except ProviderUnavailable as error: + if self.protected_hashes(context) != protected or any(sha(self.root / p) != value for p, value in owned_before.items()): + record.update(state="needs_reconcile", reason="provider failure coincided with source/evidence changes") + self.checkpoint("needs_reconcile", reason=record["reason"]) + return False + failures = int(previous.get("providerFailures", 0)) + 1 + delay = min(self.policy["providerMaxBackoffSeconds"], self.policy["providerBackoffSeconds"] * 2 ** min(failures - 1, 20)) + retry_at = datetime.fromtimestamp(time.time() + delay, timezone.utc).isoformat() + state = "provider_blocked" if failures >= self.policy["maxProviderFailures"] else "waiting_provider" + record.update(state=state, attempts=int(previous.get("attempts", 0)), providerFailures=failures, reason=str(error), nextRetryAt=retry_at) + self.checkpoint(state, reason=str(error), nextRetryAt=retry_at, providerFailures=failures) + self.event("provider.unavailable", job=job["id"], failures=failures, nextRetryAt=retry_at, reason=str(error), noAgentActions=True) + return False + except InterruptedError as error: + record.update(state="needs_reconcile", reason=str(error)) + self.checkpoint("needs_reconcile", reason=str(error)) + return False + except (ValueError, OSError, KeyError, TypeError) as error: + record.update(state="blocked" if count >= self.policy["maxAttempts"] else "retry_pending", reason=str(error)) + self.checkpoint("paused" if self.stop_requested else record["state"], reason=str(error)) + self.event("job.failed", job=job["id"], attempts=count, reason=str(error)) + return False + + def git(self, args): + log = self.directory / "git" / f"{uuid.uuid4().hex}.log" + result = self.run_process(["git", *args], self.root, log, 120) + if result["interrupted"] or result["timedOut"] or result["logLimit"]: + raise InterruptedError("Git command interrupted; reconcile its outcome before continuing") + output = log.read_text(encoding="utf-8", errors="surrogateescape") + if result["exitCode"] != 0: + raise subprocess.CalledProcessError(result["exitCode"], ["git", *args], output=output) + return output + + def remember_baseline(self, refresh=False): + location = self.directory / "baseline.json" + if location.exists() and not refresh: + return + dirty = set(self.git(["diff", "--name-only", "-z", "HEAD"]).split("\0")) + dirty.update(self.git(["ls-files", "--others", "--exclude-standard", "-z"]).split("\0")) + write_json(location, {"head": self.git(["rev-parse", "HEAD"]).strip(), "dirtyPaths": sorted(dirty - {""}), "recordedAt": now()}) + + def publish(self, context, changed_files): + if not self.policy.get("autoCommit"): + self.checkpoint("ready_to_publish", reason="automatic commit disabled") + return False + baseline = read_json(self.directory / "baseline.json") + paths = sorted(set(changed_files)) + if not paths: + raise ValueError("handoff has no declared files to commit") + for p in paths: + contained(self.root, p) + if p == ".git" or p.startswith(".git/"): + raise ValueError("cannot publish Git internals") + dirty_overlap = set(paths) & set(baseline["dirtyPaths"]) + if dirty_overlap: + raise ValueError(f"publication would include pre-existing edits: {sorted(dirty_overlap)[:12]}") + if self.git(["branch", "--show-current"]).strip() != "main": + raise ValueError("automatic publication requires branch main") + if self.git(["rev-parse", "HEAD"]).strip() != baseline["head"]: + raise ValueError("HEAD changed since the supervisor baseline") + self.checkpoint("committing", publishPaths=paths) + self.git(["add", "-f", "--", *paths]) + # --only excludes unrelated staged changes from this commit. + self.git(["commit", "--only", "-m", f"feat(web): verified workflow {context['task']}", "--", *paths]) + head = self.git(["rev-parse", "HEAD"]).strip() + self.checkpoint("committed", commit=head) + if self.policy.get("autoPush"): + self.checkpoint("pushing") + pushed = False + for attempt in range(self.policy.get("pushRetries", 6) + 1): + result = self.run_process(["git", "push", "origin", "HEAD:refs/heads/main"], self.root, self.directory / f"push-{attempt}.log", 120) + try: + remote = self.git(["ls-remote", "--refs", "origin", "refs/heads/main"]).split()[0] + except (subprocess.CalledProcessError, IndexError): + remote = None + if remote == head: + pushed = True + self.checkpoint("pushed", remoteHead=remote) + break + if result["interrupted"] or self.stop_requested: + break + deadline = time.monotonic() + min(30, 2 ** attempt) + while time.monotonic() < deadline and not self.stop_requested: + time.sleep(0.2) + if not pushed: + raise InterruptedError("push outcome not confirmed; reconcile remote HEAD before continuing") + baseline["head"] = head + write_json(self.directory / "baseline.json", baseline) + return True + + def finalize(self, context): + run_dir = self.directory / "runs" / f"handoff-{uuid.uuid4().hex[:12]}" + run_dir.mkdir(parents=True) + records = self.state["jobs"] + if not records or not all(self.receipt_valid(r) for r in records.values()): + raise ValueError("cannot finalize stale workflow receipts") + references = [{"path": r["receipt"], "sha256": r["receiptSha256"]} for r in records.values()] + self.checkpoint("finalizing") + prompt = f"""Finalize only the already verified Blender Web task {context['task']}. +Read the minimal queue/context/card first. Current pointer: {json.dumps(context)}. +Independent runtime receipts: {json.dumps(references)}. +Use repository generators to write aggregate report, status, manifest, task-context and publish the successor pointer. +Bind these verified receipts and their source/unit/build/test hashes. Set acceptanceComplete=true only if the module contract is fully met. +No source changes, tests, historical inventory/provenance rewrites, blind hash refresh, commit, push, SSH or production deployment. +Do not rewrite the parent manifest. Preserve dirty files. Never use deferred verification or route counts as completion. +If source inventory remains unverified and the current module is complete, use the repository generator to select the next source-backed module; do not invent task IDs or declare full parity. +Return structured status=ready and exact changedFiles; other array fields may be empty for this handoff-only turn. +If a required generator/evidence is unavailable, return blocked with the exact cause. Do not advance the queue on failure. +""" + result = self.worker(prompt, run_dir) + if result.get("status") != "ready": + raise ValueError(result.get("summary", "handoff worker blocked")) + if sha(self.root / context["parentManifest"]) != context["parentSha256"]: + raise InterruptedError("handoff changed the parent manifest") + for record in records.values(): + receipt = read_json(self.root / record["receipt"]) + for p, digest in receipt["inputs"].items(): + if p == context["card"]: + continue + if sha(self.root / p) != digest: + raise InterruptedError("handoff changed a verified implementation dependency") + for index, argv in enumerate(self.policy["handoffChecks"]): + process = self.run_process(argv, self.root, run_dir / f"gate-{index}.log", self.policy["checkTimeoutSeconds"]) + if process["exitCode"] != 0 or process["interrupted"] or process["timedOut"] or process["logLimit"]: + raise ValueError(f"handoff gate failed: {argv}") + proof = manifest_proof(self.root, context["task"]) + if not proof["ok"]: + raise ValueError(f"aggregate acceptance missing: {proof['reasons']}") + after = queue_context(self.root) + if proof["nextTask"] is not None and after["task"] != proof["nextTask"]: + raise ValueError("generator did not publish the authorized successor") + if proof["nextTask"] is None and after["task"] != context["task"]: + raise ValueError("terminal handoff changed the queue unexpectedly") + changed = list(result["changedFiles"]) + for record in records.values(): + changed.extend(record.get("changedFiles", [])) + receipt = read_json(self.root / record["receipt"]) + changed.append(record["receipt"]) + changed.extend(a["path"] for a in receipt["artifacts"]) + if not self.publish(context, changed): + return False + self.checkpoint("handed_off", before=context, after=after) + return True + + def doctor(self): + context = queue_context(self.root) + jobs = self.jobs(context) + return {"schemaVersion": 1, "queue": context, "taskCompletion": manifest_proof(self.root, context["task"]), "inventory": inventory_proof(self.root), "jobCount": len(jobs), "nextJob": (self.choose_job(jobs) or {}).get("id"), "tools": {n: bool(shutil.which(n)) for n in ("python3", "node", "git", "codex", "cmake")}, "policy": POLICY, "deployment": "implementation workers do not alter the live server", "state": self.state.get("state")} + + def wait_for_provider(self, record): + retry_at = record.get("nextRetryAt") + if not retry_at: + return + remaining = max(0, datetime.fromisoformat(retry_at).timestamp() - time.time()) + if remaining == 0: + return + self.checkpoint("waiting_provider", nextRetryAt=retry_at, reason=record.get("reason")) + deadline, heartbeat = time.monotonic() + remaining, time.monotonic() + with self.timed("provider_backoff"): + while time.monotonic() < deadline and not self.stop_requested and not (self.directory / "pause.request").exists(): + if time.monotonic() >= heartbeat: + self.checkpoint("waiting_provider", heartbeatAt=now()) + heartbeat = time.monotonic() + self.policy["heartbeatSeconds"] + time.sleep(min(0.25, max(0, deadline - time.monotonic()))) + + def run(self, max_cycles=0): + inherited = os.environ.pop("WBV2_AUTOPILOT_LEASE_FD", None) + with Lease(self.directory / "owner.lock", int(inherited) if inherited else None), ProjectFence(self.root): + if self.state.get("state") in ACTIVE | {"needs_reconcile"}: + self.checkpoint("needs_reconcile", reason="previous writer has no completed handoff; run read-only reconcile") + return 3 + if self.state.get("state") in {"blocked", "provider_blocked"}: + return 2 + if (self.directory / "pause.request").exists(): + self.checkpoint("paused") + return 0 + signal.signal(signal.SIGINT, self.request_stop) + signal.signal(signal.SIGTERM, self.request_stop) + self.remember_baseline() + cycles = 0 + last_success = True + self.checkpoint("preflight", reason=None) + try: + while not self.stop_requested and (max_cycles == 0 or cycles < max_cycles): + if self.run_tokens >= self.policy["maxTokensPerRun"]: + self.checkpoint("budget_exhausted", reason="per-run token budget reached") + return 4 + if (self.directory / "pause.request").exists(): + self.checkpoint("paused") + return 0 + context = queue_context(self.root) + prior = self.state.get("queue") + if prior and prior["task"] != context["task"]: + proof = manifest_proof(self.root, prior["task"]) + if not proof["ok"] or proof["nextTask"] != context["task"]: + raise ValueError("queue advanced without an accepted parent handoff") + self.state["jobs"] = {} + self.checkpoint("preflight", queue=context) + for index, argv in enumerate(self.policy["preflight"]): + proc = self.run_process(argv, self.root, self.directory / f"preflight-{index}.log", 120) + if proc["exitCode"] != 0 or proc["interrupted"] or proc["timedOut"] or proc["logLimit"]: + raise ValueError(f"context preflight failed: {argv}") + job = self.choose_job(self.jobs(context)) + if job is None: + if not self.finalize(context): + return 2 + proof = manifest_proof(self.root, context["task"]) + if proof["nextTask"] is None: + inventory = inventory_proof(self.root) + if not inventory["ok"]: + self.checkpoint("planning_required", reason="no successor but source inventory remains unverified; parity not complete") + return 2 + self.checkpoint("complete", reason="accepted terminal manifest and no unverified source units") + return 0 + continue + record = self.state["jobs"].get(job["id"], {}) + if record.get("state") in {"blocked", "provider_blocked"}: + self.checkpoint(record["state"], activeJob=job["id"], reason=record.get("reason")) + return 2 + if record.get("state") == "waiting_provider": + self.wait_for_provider(record) + if self.stop_requested or (self.directory / "pause.request").exists(): + self.checkpoint("paused") + return 2 + success = self.attempt(context, job) + last_success = success + cycles += 1 + if self.state["state"] in {"needs_reconcile", "blocked", "provider_blocked", "paused"}: + return 3 if self.state["state"] == "needs_reconcile" else 2 + if not success and self.state["state"] != "waiting_provider": + with self.timed("retry_backoff"): + deadline = time.monotonic() + self.policy.get("retryDelaySeconds", 10) + while time.monotonic() < deadline and not self.stop_requested: + time.sleep(0.2) + final_state = "paused" if self.stop_requested else "idle" if last_success else self.state["state"] + self.checkpoint(final_state, reason="stop requested" if self.stop_requested else self.state.get("reason") or "cycle limit reached") + return 0 if last_success and not self.stop_requested else 2 + except InterruptedError as error: + self.checkpoint("needs_reconcile", reason=str(error)) + return 3 + except (ValueError, OSError, KeyError, RuntimeError, subprocess.CalledProcessError) as error: + self.checkpoint("blocked", reason=str(error)) + self.event("supervisor.blocked", reason=str(error)) + return 2 + + +def main(argv=None): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("action", choices=["run", "start", "status", "timings", "doctor", "pause", "stop", "resume", "reconcile", "service"], nargs="?", default="run") + parser.add_argument("--once", action="store_true") + parser.add_argument("--max-cycles", type=int, default=0) + parser.add_argument("--retry-blocked", action="store_true") + parser.add_argument("--refresh-baseline", action="store_true", help="adopt a reviewed maintenance commit before any workflow edits/receipts") + parser.add_argument("--json", action="store_true", help="JSON timing report") + parser.add_argument("--write", action="store_true", help="write timing report snapshots") + args = parser.parse_args(argv) + if args.max_cycles < 0: + parser.error("--max-cycles must be non-negative") + runner = Autopilot() + directory = runner.directory + if args.action == "doctor": + print(json.dumps(runner.doctor(), ensure_ascii=False, indent=2)) + return 0 + if args.action == "status": + state = dict(runner.state) + state["alive"] = alive(state.get("pid")) and identity(state["pid"]) == state.get("identity") + state["timezone"] = "Asia/Shanghai" + print(json.dumps(display_times(state), ensure_ascii=False, indent=2)) + return 0 + if args.action == "timings": + report = timing_report(directory, runner.state) + if args.write: + write_json(directory / "timing-report.json", report) + (directory / "timing-report.md").write_text(format_report(report) + "\n", encoding="utf-8") + print(json.dumps(report, ensure_ascii=False, indent=2) if args.json else format_report(report)) + return 0 + if args.action == "service": + def quote(value): + if "\n" in value or "\r" in value: + raise ValueError("newline in systemd value") + return '"' + value.replace("\\", "\\\\").replace('"', '\\"').replace("%", "%%") + '"' + unit = Path.home() / ".config/systemd/user/blender-web-autopilot.service" + unit.parent.mkdir(parents=True, exist_ok=True) + executable = Path(__file__).with_name("run_web_product_migration.py") + unit.write_text("[Unit]\nDescription=Blender Web source migration supervisor\nAfter=network-online.target\n\n[Service]\nType=simple\n" + f"WorkingDirectory={quote(str(ROOT))}\nExecStart={quote(sys.executable)} {quote(str(executable))} run\nEnvironment={quote('PATH=' + os.environ.get('PATH', '/usr/bin:/bin'))}\n" + "Restart=on-failure\nRestartPreventExitStatus=2 3 4\nRestartSec=10\nKillMode=control-group\nTimeoutStopSec=15\n\n[Install]\nWantedBy=default.target\n", encoding="utf-8") + print(f"Created {unit}; enable with systemctl --user daemon-reload and systemctl --user enable --now blender-web-autopilot") + return 0 + if args.action in {"pause", "stop"}: + directory.mkdir(parents=True, exist_ok=True) + write_json(directory / "pause.request", {"requestedAt": now()}) + owner = read_json(directory / "owner.lock", {}) + if alive(owner.get("pid")) and identity(owner["pid"]) == owner.get("identity"): + os.kill(owner["pid"], signal.SIGTERM) + deadline = time.monotonic() + 10 + while alive(owner["pid"]) and identity(owner["pid"]) == owner.get("identity") and time.monotonic() < deadline: + time.sleep(0.1) + print("Pause requested; interrupted work requires reconciliation before retry.") + return 0 + if args.action == "reconcile": + print(json.dumps({"queue": queue_context(ROOT), "state": runner.state, "childAlive": alive(runner.state.get("childPid")), "receipts": {key: runner.receipt_valid(record) for key, record in runner.state["jobs"].items()}, "decision": "read-only; inspect interrupted edits before resume --retry-blocked"}, ensure_ascii=False, indent=2)) + return 0 + if args.action == "resume": + with Lease(directory / "owner.lock"): + if alive(runner.state.get("childPid")) and identity(runner.state["childPid"]) == runner.state.get("childIdentity"): + parser.error("previous child is alive; stop and reconcile first") + if runner.state["state"] in ACTIVE | {"needs_reconcile", "blocked", "provider_blocked"} and not args.retry_blocked: + parser.error("run reconcile; --retry-blocked acknowledges the inspected repository state") + for record in runner.state["jobs"].values(): + if record.get("state") in ACTIVE | {"needs_reconcile", "blocked", "provider_blocked"} or (args.retry_blocked and record.get("state") != "verified"): + record.update(state="retry_pending", attempts=0, providerFailures=0) + record.pop("nextRetryAt", None) + if args.refresh_baseline and any(record.get("receipt") or record.get("changedFiles") for record in runner.state["jobs"].values()): + parser.error("cannot refresh a baseline containing workflow edits or verified receipts") + (directory / "pause.request").unlink(missing_ok=True) + if args.refresh_baseline: + runner.remember_baseline(refresh=True) + runner.checkpoint("idle", reason="explicit resume") + if args.action in {"start", "resume"}: + with Lease(directory / "owner.lock") as lease: + if (directory / "pause.request").exists(): + parser.error("paused; use resume") + if runner.state["state"] in ACTIVE | {"needs_reconcile", "blocked", "provider_blocked"}: + parser.error("run reconcile before restarting interrupted or blocked work") + command = [sys.executable, str(Path(__file__).with_name("run_web_product_migration.py")), "run", "--max-cycles", str(1 if args.once else args.max_cycles)] + fd = lease.stream.fileno() + with (directory / "daemon.log").open("ab") as log: + child = subprocess.Popen(command, cwd=ROOT, stdin=subprocess.DEVNULL, stdout=log, stderr=subprocess.STDOUT, start_new_session=True, pass_fds=(fd,), env={**os.environ, "WBV2_AUTOPILOT_LEASE_FD": str(fd)}) + lease.transferred = True + print(json.dumps({"launchedPid": child.pid, "statusCommand": "python3 my-tools/run_web_product_migration.py status", "log": str(directory / "daemon.log")})) + return 0 + return runner.run(1 if args.once else args.max_cycles) + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/my-tools/wbv2_autopilot_policy.json b/my-tools/wbv2_autopilot_policy.json new file mode 100644 index 000000000..6d6fe3611 --- /dev/null +++ b/my-tools/wbv2_autopilot_policy.json @@ -0,0 +1,42 @@ +{ + "schemaVersion": 1, + "strategy": "business_module_and_function_route", + "sourceAuthority": "blender-5.2.0/source/blender", + "sourceFirst": true, + "origin": "https://49.232.250.35:58014", + "sandbox": "workspace-write", + "workerTimeoutSeconds": 1800, + "checkTimeoutSeconds": 1800, + "heartbeatSeconds": 5, + "monitorPollSeconds": 0.25, + "modelStartTimeoutSeconds": 60, + "modelIdleTimeoutSeconds": 180, + "providerBackoffSeconds": 30, + "providerMaxBackoffSeconds": 240, + "maxProviderFailures": 4, + "maxAttempts": 3, + "maxTokensPerRun": 500000, + "maxLogBytes": 33554432, + "maxBuildJobs": 8, + "retryDelaySeconds": 10, + "autoCommit": true, + "autoPush": true, + "pushRetries": 6, + "priority": ["SERVER-OPERATOR-HTTP-PROVIDER", "SERVER-OPERATOR-SCHEMA-PALETTE", "BROWSER-EQUIVALENT-RUNTIME"], + "requiredChecks": ["source_build", "typecheck", "lint", "chromium", "positive", "negative", "undo_redo", "save_reopen", "determinism"], + "preflight": [["node", "tools/web/check-task-context.mjs"], ["node", "tools/web/check-context-governance.mjs"]], + "handoffChecks": [ + ["node", "tools/web/check-task-context.mjs"], + ["node", "tools/web/check-context-governance.mjs"], + ["node", "tools/web/check-source-dynamic-inventory.mjs"], + ["node", "tools/web/check-execution-control-plane.mjs"], + ["node", "tools/web/check-task-index.mjs"], + ["node", "tools/web/check-blender-next-task-plan.mjs"], + ["git", "diff", "--check"] + ], + "knownFindings": [ + "The live /api/server-operator-job POST describe returns HTTP 405. Implement deployment integration and test a disposable local deployment; do not alter the live server during implementation.", + "SCREEN_OT_area_split switches Modeling to Layout without adding an editor. Implement the actual source-equivalent behavior, not a generic action-group alias.", + "Of 1025 recorded VERIFIED units, 902 have drifted direct evidence references. Reverify behavior and create current receipts; never rewrite historical hashes to silence a gate." + ] +} diff --git a/my-tools/wbv2_timing.py b/my-tools/wbv2_timing.py new file mode 100644 index 000000000..d60ebb375 --- /dev/null +++ b/my-tools/wbv2_timing.py @@ -0,0 +1,211 @@ +"""Incremental process telemetry and minute-labelled execution reports.""" +from __future__ import annotations + +import json +import re +import shlex +from collections import defaultdict +from datetime import datetime, timezone +from zoneinfo import ZoneInfo + +LOCAL_ZONE = ZoneInfo("Asia/Shanghai") + + +def minute_label(value): + if not value: + return None + try: + return datetime.fromisoformat(value.replace("Z", "+00:00")).astimezone(LOCAL_ZONE).strftime("%Y-%m-%d %H:%M") + except (ValueError, TypeError): + return value + + +def display_times(value): + if isinstance(value, list): + return [display_times(item) for item in value] + if not isinstance(value, dict): + return value + return {key: minute_label(item) if key.endswith("At") and isinstance(item, str) else display_times(item) for key, item in value.items()} + + +def command_phase(argv): + if not argv: + return "other" + if argv[0] == "codex": + return "model_request" + if argv[0] == "git": + return "git_" + (argv[1] if len(argv) > 1 else "other") + if any("task-context" in arg or "context-governance" in arg for arg in argv): + return "context_check" + if argv[0] in {"cmake", "ninja"}: + return "build" + return "command" + + +def item_phase(item): + kind = item.get("type", "unknown") + if kind == "file_change": + return "editing" + if kind != "command_execution": + return "tool" if kind != "agent_message" else "model_response" + try: + argv = shlex.split(item.get("command", "")) + if len(argv) >= 3 and argv[0].endswith(("bash", "sh")) and argv[1] in {"-lc", "-c"}: + argv = shlex.split(argv[2]) + except ValueError: + return "command" + if not argv: + return "command" + if argv[0] in {"cat", "sed", "rg", "ls", "head", "tail", "wc", "find", "stat"} or any("search-wbv2" in arg or "print-task-context" in arg for arg in argv): + return "reading" + if "apply_patch" in argv[0]: + return "editing" + if any("test" in arg or "lint" in arg or "typecheck" in arg for arg in argv): + return "testing" + return command_phase(argv) + + +class WorkerTrace: + """Times observed JSONL events; never infers model CPU time from silence.""" + def __init__(self): + self.offset = 0 + self.pending = b"" + self.turn_started = False + self.actions_seen = False + self.unknown_output = False + self.first_event = None + self.first_action = None + self.last_progress = 0.0 + self.last_output = 0.0 + self.provider_error = None + self.errors = 0 + self.active_items = {} + self.items = [] + self.counts = defaultdict(int) + + def feed(self, event, elapsed): + kind = event.get("type", "unknown") + if not isinstance(kind, str): + self.unknown_output = True + return + self.counts[kind] += 1 + self.first_event = elapsed if self.first_event is None else self.first_event + if kind == "turn.started": + self.turn_started = True + if kind in {"error", "turn.failed"}: + self.errors += 1 + error = event.get("error") + message = event.get("message") or (error.get("message", "") if isinstance(error, dict) else error) or "" + if not isinstance(message, str): + message = str(message) + if re.search(r"concurrency limit|overload|rate.?limit|too many requests|\b429\b|\b503\b|service unavailable", message, re.I): + self.provider_error = re.sub(r"sk-[A-Za-z0-9_-]+", "[redacted]", message)[:600] + if kind.startswith("item."): + self.actions_seen = True + self.first_action = elapsed if self.first_action is None else self.first_action + self.last_progress = elapsed + item = event.get("item") or {} + if not isinstance(item, dict): + self.unknown_output = True + return + key = item.get("id") + if kind == "item.started" and key: + self.active_items[key] = {"id": key, "phase": item_phase(item), "startedSeconds": elapsed} + elif kind == "item.completed": + record = self.active_items.pop(key, {"id": key, "phase": item_phase(item), "startedSeconds": elapsed}) + record.update(finishedSeconds=elapsed, durationSeconds=max(0, elapsed - record["startedSeconds"]), status=item.get("status"), exitCode=item.get("exit_code")) + self.items.append(record) + if kind == "turn.completed": + self.last_progress = elapsed + + def read(self, path, elapsed): + with path.open("rb") as stream: + stream.seek(self.offset) + chunk = stream.read() + self.offset = stream.tell() + if not chunk: + return + self.last_output = elapsed + lines = (self.pending + chunk).split(b"\n") + self.pending = lines.pop() + for line in lines: + if not line.strip(): + continue + try: + event = json.loads(line) + if not isinstance(event, dict): + raise ValueError("non-object event") + self.feed(event, elapsed) + except (ValueError, UnicodeDecodeError): + self.unknown_output = True + + @property + def safe_to_retry(self): + return self.turn_started and not self.actions_seen and not self.unknown_output and not self.pending.strip() + + def snapshot(self, elapsed): + return { + "firstEventSeconds": self.first_event, + "firstActionSeconds": self.first_action, + "providerWaitSeconds": self.first_action if self.first_action is not None else elapsed, + "idleSeconds": max(0, elapsed - self.last_progress), + "actionsSeen": self.actions_seen, + "safeToRetry": self.safe_to_retry, + "providerError": self.provider_error, + "errorCount": self.errors, + "eventCounts": dict(self.counts), + "activeItems": list(self.active_items.values()), + "items": self.items, + } + + +def timing_report(directory, state=None): + rows, worker_details, seen, intervals = [], [], set(), [] + path = directory / "events.jsonl" + if path.exists(): + with path.open(encoding="utf-8") as stream: + for line in stream: + try: + event = json.loads(line) + except ValueError: + continue + if event.get("event") not in {"process.finished", "timing.span"}: + continue + key = (event.get("log"), event.get("startedAt"), event.get("phase")) + if key in seen: + continue + seen.add(key) + phase = event.get("phase") or command_phase(event.get("argv", [])) + seconds = max(0, event.get("durationSeconds", 0)) + try: + intervals.append((datetime.fromisoformat(event["startedAt"]), datetime.fromisoformat(event.get("finishedAt") or event["time"]))) + except (KeyError, ValueError): + pass + rows.append({"phase": phase, "start": minute_label(event.get("startedAt")), "finish": minute_label(event.get("finishedAt") or event.get("time")), "seconds": seconds, "minutes": round(seconds / 60, 4), "exitCode": event.get("exitCode"), "log": event.get("log"), "providerAbort": event.get("providerAbort")}) + if event.get("workerTrace"): + worker_details.append({"log": event.get("log"), **event["workerTrace"]}) + totals = defaultdict(lambda: {"count": 0, "seconds": 0.0, "maxSeconds": 0.0}) + for row in rows: + total = totals[row["phase"]] + total["count"] += 1 + total["seconds"] += row["seconds"] + total["maxSeconds"] = max(total["maxSeconds"], row["seconds"]) + measured = sum(row["seconds"] for row in rows) + wall = (max(end for _, end in intervals) - min(start for start, _ in intervals)).total_seconds() if intervals else 0 + summary = [{"phase": phase, **{k: round(v, 6) if isinstance(v, float) else v for k, v in total.items()}, "minutes": round(total["seconds"] / 60, 4), "sharePercent": round(total["seconds"] / measured * 100, 2) if measured else 0} for phase, total in totals.items()] + summary.sort(key=lambda row: row["seconds"], reverse=True) + current = dict((state or {}).get("currentProcess") or {}) + if current.get("status") == "running" and current.get("startedAt"): + current["elapsedMinutes"] = round((datetime.now(timezone.utc) - datetime.fromisoformat(current["startedAt"])).total_seconds() / 60, 4) + return {"schemaVersion": 1, "observedAt": datetime.now(LOCAL_ZONE).strftime("%Y-%m-%d %H:%M"), "timezone": "Asia/Shanghai", "labelPrecision": "minute", "totalMeasuredMinutes": round(measured / 60, 4), "wallClockMinutes": round(wall / 60, 4), "outsideMeasuredStepsMinutes": round(max(0, wall - measured) / 60, 4), "summary": summary, "steps": rows, "workers": worker_details, "current": display_times(current), "accounting": "Top-level measured spans only; worker item durations are nested and must not be added again. Outside measured steps includes unrecorded retry, scheduling or manual pause gaps; legacy logs cannot attribute them further."} + + +def format_report(report): + lines = [f"Observed: {report['observedAt']} (Asia/Shanghai)", "Phase | Count | Minutes | Share", "--- | ---: | ---: | ---:"] + lines += [f"{r['phase']} | {r['count']} | {r['minutes']:.4f} | {r['sharePercent']:.2f}%" for r in report["summary"]] + lines += [f"Measured: {report['totalMeasuredMinutes']:.4f} minutes; outside measured steps: {report['outsideMeasuredStepsMinutes']:.4f} minutes."] + lines += ["", "Start | Finish | Phase | Minutes | Exit", "--- | --- | --- | ---: | ---:"] + lines += [f"{r['start']} | {r['finish']} | {r['phase']} | {r['minutes']:.4f} | {r['exitCode']}" for r in report["steps"]] + if report["current"]: + lines += ["", "Current: " + json.dumps(report["current"], ensure_ascii=False)] + return "\n".join(lines) diff --git a/tests/golden/WBV2-P1424-001/autopilot-implementation-report.json b/tests/golden/WBV2-P1424-001/autopilot-implementation-report.json new file mode 100644 index 000000000..5b6032b5d --- /dev/null +++ b/tests/golden/WBV2-P1424-001/autopilot-implementation-report.json @@ -0,0 +1,60 @@ +{ + "schemaVersion": 1, + "operation": "PYTHON_UNATTENDED_SUPERVISOR_IMPLEMENTATION", + "observedOn": "2026-09-08", + "updatedAt": "2026-09-08 10:55", + "timezone": "Asia/Shanghai", + "queueTask": "WBV2-P1424-001", + "parentManifest": "tests/golden/WBV2-P1424-000/manifest.json", + "programImplemented": true, + "blenderMigrationComplete": false, + "queueAdvancedByThisChange": false, + "sourceInventory": { + "unitCount": 3802, + "verifiedUnits": 1025, + "unverifiedUnits": 2777, + "unitsWithInvalidEvidenceReferences": 902, + "sourceTreeSha256": "311791df5e2b96c31ee9cefd5ab0c9a8ded87309f1a814c3b92dec328a607d6a", + "boundUnitDelta": 0 + }, + "checks": [ + { "command": "python3 -m unittest discover -s my-tools -p test_wbv2_autopilot.py", "exitCode": 0, "passedTests": 33 }, + { "command": "npm --prefix web run test:context-governance", "exitCode": 0, "passedTests": 11 }, + { "command": "python3 -m py_compile my-tools/wbv2_autopilot.py my-tools/run_web_product_migration.py my-tools/show_blender_web_scheduler.py", "exitCode": 0 }, + { "command": "node tools/web/run-wbv2-scheduler.mjs --preflight-only", "exitCode": 2, "expected": true, "reason": "incomplete task has no implementation entrypoint; index termination is no longer false completion" }, + { "command": "bash -n my-tools/start_unattended.sh", "exitCode": 0 }, + { "command": "git diff --check", "exitCode": 0 } + ], + "launchSnapshot": { + "historicalSnapshot": true, + "command": "python3 my-tools/run_web_product_migration.py start", + "exitCode": 0, + "pid": 2035708, + "childPid": 2035763, + "state": "implementing", + "activeJob": "SERVER-OPERATOR-HTTP-PROVIDER", + "statusCommand": "python3 my-tools/run_web_product_migration.py status", + "checkpoint": "tests/golden/WBV2/autopilot/state.json" + }, + "artifacts": { + "supervisor": { "path": "my-tools/wbv2_autopilot.py", "sha256": "c1ef9f130fac5913480c4c5a73ddced87275b8f6956585d631cedf3beac79acb" }, + "timing": { "path": "my-tools/wbv2_timing.py", "sha256": "3bdfd71ba16a28fda9fad0a3cc993a8c64aa93d9dcfc65c0ed581b4f507dfdfd" }, + "policy": { "path": "my-tools/wbv2_autopilot_policy.json", "sha256": "430cfee026deaf3d72bb3417bc640ed0e4f37c1ad1860a947cc54b2dd4586dc7" }, + "tests": { "path": "my-tools/test_wbv2_autopilot.py", "sha256": "5733cdc2041a0df94942d48f677249a008fae0e75c07b12d113ecfb16ceb3e9e" }, + "testLog": { "path": "tests/golden/WBV2-P1424-001/autopilot-tests.log", "sha256": "fba75567456bcf394e2dbb73fbbd46b7c6b96268d804c7a7b60b3c0cbd12d1c3" }, + "entrypoint": { "path": "my-tools/run_web_product_migration.py", "sha256": "310a740d4d76d2a0f330a9c9d1f5583d412a38894382aea69e4eeb53b163d828" }, + "documentation": { "path": "my-tools/AUTOPILOT.md", "sha256": "c8888bcae987dfde1bbffc020d659e1c675ad800655725aede7b11c9545fdd94" }, + "performance": { "path": "tests/golden/WBV2-P1424-001/performance-optimization-report.json", "sha256": "6cccd401292d4f0f008a4716aa5f222ae0c55e716aee23fe34bfd21acbe6896f" } + }, + "limits": { + "workerAndCheckTimeoutSeconds": 1800, + "modelStartTimeoutSeconds": 60, + "modelIdleTimeoutSeconds": 180, + "providerFailureBudget": 4, + "attemptsPerWorkflow": 3, + "reportedTokensPerRun": 500000, + "buildJobs": 8, + "runtime": "Chromium only", + "liveDeployment": "not performed by implementation workers" + } +} diff --git a/tests/golden/WBV2-P1424-001/autopilot-tests.log b/tests/golden/WBV2-P1424-001/autopilot-tests.log new file mode 100644 index 000000000..ef7189c83 --- /dev/null +++ b/tests/golden/WBV2-P1424-001/autopilot-tests.log @@ -0,0 +1,21 @@ +....{"time": "2026-09-08 10:54", "event": "process.started", "argv": ["git", "diff", "--name-only", "-z", "HEAD"], "cwd": ".", "phase": "git_diff", "startedAt": "2026-09-08 10:54", "log": "tests/golden/WBV2/autopilot/git/ffbfeed16e5a4a3e90ec5d90850e3a2e.log"} +{"time": "2026-09-08 10:54", "event": "process.finished", "argv": ["git", "diff", "--name-only", "-z", "HEAD"], "cwd": ".", "phase": "git_diff", "startedAt": "2026-09-08 10:54", "log": "tests/golden/WBV2/autopilot/git/ffbfeed16e5a4a3e90ec5d90850e3a2e.log", "exitCode": 0, "durationSeconds": 0.002486, "interrupted": false, "timedOut": false, "logLimit": false, "providerAbort": null, "logSha256": "7529b91ac69a737f5f0a199392966ea417fd1a690365e2d1ef9bf19df008979a", "finishedAt": "2026-09-08 10:54"} +{"time": "2026-09-08 10:54", "event": "process.started", "argv": ["git", "ls-files", "--others", "--exclude-standard", "-z"], "cwd": ".", "phase": "git_ls-files", "startedAt": "2026-09-08 10:54", "log": "tests/golden/WBV2/autopilot/git/5273e581d053477cba6c9780836eb952.log"} +{"time": "2026-09-08 10:54", "event": "process.finished", "argv": ["git", "ls-files", "--others", "--exclude-standard", "-z"], "cwd": ".", "phase": "git_ls-files", "startedAt": "2026-09-08 10:54", "log": "tests/golden/WBV2/autopilot/git/5273e581d053477cba6c9780836eb952.log", "exitCode": 0, "durationSeconds": 0.001814, "interrupted": false, "timedOut": false, "logLimit": false, "providerAbort": null, "logSha256": "1fc2ea0a9701bb979fde2750cccf75dd64902f090932bc6617d69532bf03ad05", "finishedAt": "2026-09-08 10:54"} +{"time": "2026-09-08 10:54", "event": "process.started", "argv": ["git", "rev-parse", "HEAD"], "cwd": ".", "phase": "git_rev-parse", "startedAt": "2026-09-08 10:54", "log": "tests/golden/WBV2/autopilot/git/35eef3bff75f46b5b1243731e96356c6.log"} +{"time": "2026-09-08 10:54", "event": "process.finished", "argv": ["git", "rev-parse", "HEAD"], "cwd": ".", "phase": "git_rev-parse", "startedAt": "2026-09-08 10:54", "log": "tests/golden/WBV2/autopilot/git/35eef3bff75f46b5b1243731e96356c6.log", "exitCode": 0, "durationSeconds": 0.001906, "interrupted": false, "timedOut": false, "logLimit": false, "providerAbort": null, "logSha256": "1fdd00ec61025cc7d1255f9b001245011b6d2afba27f91cc94fa578d4684c11c", "finishedAt": "2026-09-08 10:54"} +{"time": "2026-09-08 10:54", "event": "process.started", "argv": ["git", "branch", "--show-current"], "cwd": ".", "phase": "git_branch", "startedAt": "2026-09-08 10:54", "log": "tests/golden/WBV2/autopilot/git/c83a2294ac1f4387aa63f7fe4381485d.log"} +{"time": "2026-09-08 10:54", "event": "process.finished", "argv": ["git", "branch", "--show-current"], "cwd": ".", "phase": "git_branch", "startedAt": "2026-09-08 10:54", "log": "tests/golden/WBV2/autopilot/git/c83a2294ac1f4387aa63f7fe4381485d.log", "exitCode": 0, "durationSeconds": 0.001841, "interrupted": false, "timedOut": false, "logLimit": false, "providerAbort": null, "logSha256": "6403203dd5a0867eb14d104ee8a73730bd72dd9ad92e78d996a6dba0a5dcfc01", "finishedAt": "2026-09-08 10:54"} +{"time": "2026-09-08 10:54", "event": "process.started", "argv": ["git", "rev-parse", "HEAD"], "cwd": ".", "phase": "git_rev-parse", "startedAt": "2026-09-08 10:54", "log": "tests/golden/WBV2/autopilot/git/4d1296bf4b9240469c5f08036a2f10d8.log"} +{"time": "2026-09-08 10:54", "event": "process.finished", "argv": ["git", "rev-parse", "HEAD"], "cwd": ".", "phase": "git_rev-parse", "startedAt": "2026-09-08 10:54", "log": "tests/golden/WBV2/autopilot/git/4d1296bf4b9240469c5f08036a2f10d8.log", "exitCode": 0, "durationSeconds": 0.001801, "interrupted": false, "timedOut": false, "logLimit": false, "providerAbort": null, "logSha256": "1fdd00ec61025cc7d1255f9b001245011b6d2afba27f91cc94fa578d4684c11c", "finishedAt": "2026-09-08 10:54"} +{"time": "2026-09-08 10:54", "event": "process.started", "argv": ["git", "add", "-f", "--", "source.cpp"], "cwd": ".", "phase": "git_add", "startedAt": "2026-09-08 10:54", "log": "tests/golden/WBV2/autopilot/git/a85a3037de4e4423887db775e64c03cd.log"} +{"time": "2026-09-08 10:54", "event": "process.finished", "argv": ["git", "add", "-f", "--", "source.cpp"], "cwd": ".", "phase": "git_add", "startedAt": "2026-09-08 10:54", "log": "tests/golden/WBV2/autopilot/git/a85a3037de4e4423887db775e64c03cd.log", "exitCode": 0, "durationSeconds": 0.00186, "interrupted": false, "timedOut": false, "logLimit": false, "providerAbort": null, "logSha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", "finishedAt": "2026-09-08 10:54"} +{"time": "2026-09-08 10:54", "event": "process.started", "argv": ["git", "commit", "--only", "-m", "feat(web): verified workflow WBV2-P42-001", "--", "source.cpp"], "cwd": ".", "phase": "git_commit", "startedAt": "2026-09-08 10:54", "log": "tests/golden/WBV2/autopilot/git/32b2d67b4286444790afce197b4652da.log"} +{"time": "2026-09-08 10:54", "event": "process.finished", "argv": ["git", "commit", "--only", "-m", "feat(web): verified workflow WBV2-P42-001", "--", "source.cpp"], "cwd": ".", "phase": "git_commit", "startedAt": "2026-09-08 10:54", "log": "tests/golden/WBV2/autopilot/git/32b2d67b4286444790afce197b4652da.log", "exitCode": 0, "durationSeconds": 0.004922, "interrupted": false, "timedOut": false, "logLimit": false, "providerAbort": null, "logSha256": "4a31687c5f083e9a80e973f3c90f27e979ad11c21ce645b45fbf77f105a5e39a", "finishedAt": "2026-09-08 10:54"} +{"time": "2026-09-08 10:54", "event": "process.started", "argv": ["git", "rev-parse", "HEAD"], "cwd": ".", "phase": "git_rev-parse", "startedAt": "2026-09-08 10:54", "log": "tests/golden/WBV2/autopilot/git/f322aaa82f25411ea2e03697d042d681.log"} +{"time": "2026-09-08 10:54", "event": "process.finished", "argv": ["git", "rev-parse", "HEAD"], "cwd": ".", "phase": "git_rev-parse", "startedAt": "2026-09-08 10:54", "log": "tests/golden/WBV2/autopilot/git/f322aaa82f25411ea2e03697d042d681.log", "exitCode": 0, "durationSeconds": 0.001736, "interrupted": false, "timedOut": false, "logLimit": false, "providerAbort": null, "logSha256": "d5bbe3d9e19db362f6e234daf00ffde3e332d2bba64c421d7ff72300822ecc89", "finishedAt": "2026-09-08 10:54"} +............................. +---------------------------------------------------------------------- +Ran 33 tests in 2.770s + +OK diff --git a/tests/golden/WBV2-P1424-001/deployed-audit/browser-area-split-result.png b/tests/golden/WBV2-P1424-001/deployed-audit/browser-area-split-result.png new file mode 100644 index 000000000..edc580c3e Binary files /dev/null and b/tests/golden/WBV2-P1424-001/deployed-audit/browser-area-split-result.png differ diff --git a/tests/golden/WBV2-P1424-001/deployed-audit/chromium-report.json b/tests/golden/WBV2-P1424-001/deployed-audit/chromium-report.json new file mode 100644 index 000000000..ad9d9e318 --- /dev/null +++ b/tests/golden/WBV2-P1424-001/deployed-audit/chromium-report.json @@ -0,0 +1,272 @@ +{ + "observedAt": "2026-09-08T01:24:58.634Z", + "origin": "https://49.232.250.35:58014", + "browser": "Chromium", + "steps": [ + { + "name": "startup", + "status": "PASS", + "durationMs": 34167, + "detail": { + "title": "Blender 5.2.0 LTS - Web", + "secureContext": true, + "crossOriginIsolated": true, + "scripts": [ + "https://49.232.250.35:58014/assets/index-DpqZcb_t.js" + ] + } + }, + { + "name": "open_fixture", + "status": "PASS", + "durationMs": 692, + "detail": { + "objects": 3, + "coverage": "Feature Routes\n3802/3802 source units classified\nMain 1755 · Server 1613 · Browser 434 · Unavailable 0\nRoute gaps 0 · Evidence 1025 verified / 2777 unverified" + } + }, + { + "name": "add_cube", + "status": "PASS", + "durationMs": 391, + "detail": { + "objects": 4 + } + }, + { + "name": "undo_redo", + "status": "PASS", + "durationMs": 446, + "detail": { + "undoObjects": 3, + "redoObjects": 4 + } + }, + { + "name": "save_reopen", + "status": "PASS", + "durationMs": 1185, + "detail": { + "suggestedFilename": "blender-web.blend", + "byteLength": 205638, + "sha256": "29f7f3f90e04454b47c2bb715515bb41badfa87e4b73e73e95345d5517222f90", + "reopenedObjects": 4 + } + }, + { + "name": "duplicate_delete", + "status": "PASS", + "durationMs": 773, + "detail": { + "duplicatedObjects": 5, + "deletedObjects": 4 + } + }, + { + "name": "f3_local_operator_properties", + "status": "PASS", + "durationMs": 1121, + "detail": { + "form": "MESH_OT_primitive_cube_add\n执行", + "controls": 0 + } + }, + { + "name": "f3_server_operator_properties", + "status": "FAIL", + "durationMs": 1332, + "error": "{\"alert\":[\"SERVER_OPERATOR_HTTP_FAILED: 405\"],\"controls\":0}\n\n1 !== 0\n" + }, + { + "name": "browser_equivalent_area_split", + "status": "FAIL", + "durationMs": 1492, + "error": "Area split switched workspace instead of splitting the active editor\n+ actual - expected\n\n+ 'Layout'\n- 'Modeling'\n" + }, + { + "name": "workspace_surfaces", + "status": "PASS", + "durationMs": 2469, + "detail": { + "scope": "workspace presence only; not full functional verification", + "surfaces": [ + { + "workspace": "Layout", + "editors": [ + "3D Viewport", + "Outliner", + "Properties", + "Timeline" + ] + }, + { + "workspace": "Modeling", + "editors": [ + "3D Viewport", + "Outliner", + "Properties", + "Timeline" + ] + }, + { + "workspace": "Sculpting", + "editors": [ + "3D Viewport", + "Outliner", + "Properties", + "Timeline" + ] + }, + { + "workspace": "UV Editing", + "editors": [ + "Image Editor", + "3D Viewport", + "Outliner", + "Properties", + "Timeline" + ] + }, + { + "workspace": "Texture Paint", + "editors": [ + "Image Editor", + "3D Viewport", + "Outliner", + "Properties", + "Timeline" + ] + }, + { + "workspace": "Shading", + "editors": [ + "Image Editor", + "Shader Editor", + "File Browser", + "3D Viewport", + "Outliner", + "Properties", + "Timeline" + ] + }, + { + "workspace": "Animation", + "editors": [ + "3D Viewport", + "3D Viewport", + "Outliner", + "Properties", + "Dope Sheet" + ] + }, + { + "workspace": "Rendering", + "editors": [ + "Render Result", + "3D Viewport", + "Outliner", + "Properties", + "Timeline" + ] + }, + { + "workspace": "Compositing", + "editors": [ + "Image Editor", + "Compositor", + "3D Viewport", + "Outliner", + "Properties", + "Timeline" + ] + }, + { + "workspace": "Geometry Nodes", + "editors": [ + "Geometry Nodes", + "Spreadsheet", + "3D Viewport", + "Outliner", + "Properties", + "Timeline" + ] + }, + { + "workspace": "Scripting", + "editors": [ + "Text Editor", + "Python Console", + "Info", + "Outliner", + "3D Viewport", + "Outliner", + "Properties", + "Timeline" + ] + } + ] + } + }, + { + "name": "desktop_render", + "status": "PASS", + "durationMs": 131, + "detail": { + "canvases": [ + { + "width": 1119, + "height": 713, + "rect": { + "x": 0, + "y": 58, + "width": 1119, + "height": 713, + "top": 58, + "right": 1119, + "bottom": 771, + "left": 0 + } + } + ], + "bodyWidth": 1440, + "viewportWidth": 1440, + "wasmResources": [ + { + "url": "https://49.232.250.35:58014/vendor/blender/single/web_engine.wasm", + "duration": 135.66500002145767, + "transferSize": 369064 + } + ] + } + } + ], + "errors": [], + "failedRequests": [], + "badResponses": [ + { + "url": "https://49.232.250.35:58014/api/server-operator-job", + "status": 405 + } + ], + "areaSplitObservation": { + "before": { + "workspace": "Modeling", + "editors": [ + "3D Viewport", + "Outliner", + "Properties", + "Timeline" + ] + }, + "after": { + "workspace": "Layout", + "editors": [ + "3D Viewport", + "Outliner", + "Properties", + "Timeline" + ] + } + }, + "finishedAt": "2026-09-08T01:25:42.978Z" +} diff --git a/tests/golden/WBV2-P1424-001/deployed-audit/completion-audit.json b/tests/golden/WBV2-P1424-001/deployed-audit/completion-audit.json new file mode 100644 index 000000000..6da351954 --- /dev/null +++ b/tests/golden/WBV2-P1424-001/deployed-audit/completion-audit.json @@ -0,0 +1,172 @@ +{ + "schemaVersion": 1, + "operation": "DEPLOYED_BLENDER_COMPLETION_AUDIT", + "observedAt": "2026-09-08T01:29:54.546Z", + "origin": "https://49.232.250.35:58014/", + "assessment": "Core online editing is functional; full desktop Blender migration is not complete or established by current evidence.", + "codeOrServerConfigurationChanged": false, + "productionDataModified": false, + "testMutationScope": "Fresh isolated Chromium context and repository-owned basic_scene.blend; no server operator submit job was executed.", + "newVerifiedInventoryUnits": 0, + "declaredImplementation": { + "modules": 16, + "implementedModules": 16, + "tasks": 34, + "implementedTasks": 34, + "verificationPolicy": "deferred_until_user_reports" + }, + "inventory": { + "unitCount": 3802, + "sourceTreeSha256": "311791df5e2b96c31ee9cefd5ab0c9a8ded87309f1a814c3b92dec328a607d6a", + "routeCounts": { + "BROWSER_EQUIVALENT": 434, + "SERVER_NATIVE": 1613, + "WEB_MAIN": 1755 + }, + "behavioralEvidence": { + "status": "PARTIAL", + "verifiedUnits": 1025, + "unverifiedUnits": 2777, + "policy": "route classification does not replace exact behavioral evidence" + }, + "recordedEvidencePercent": 26.96, + "byKind": { + "modifier-source": { + "total": 97, + "recordedVerified": 95, + "unverified": 2 + }, + "node": { + "total": 497, + "recordedVerified": 497, + "unverified": 0 + }, + "operator-macro": { + "total": 58, + "recordedVerified": 0, + "unverified": 58 + }, + "operator": { + "total": 2018, + "recordedVerified": 31, + "unverified": 1987 + }, + "rna-struct": { + "total": 979, + "recordedVerified": 306, + "unverified": 673 + }, + "web-command": { + "total": 153, + "recordedVerified": 96, + "unverified": 57 + } + }, + "sourceInventoryCheck": { + "command": "node tools/web/check-source-dynamic-inventory.mjs", + "exitCode": 0 + }, + "routeCatalogCheck": { + "command": "node tools/web/check-blender-feature-route-catalog.mjs", + "exitCode": 0 + } + }, + "deployment": { + "releaseId": "731af06aee6a2d2b61b902db9fd4b7bd5b04474e4689c48baf213fd5fcb3769f", + "wasmModuleManifestMatchesLocal": true, + "testedWasmSha256": "1c89a1fd0e00e30330d151cb9a42d9d54aabd5ed2c9ae45dd3b1961d9a0c75d5", + "deploymentCheck": { + "command": "node tools/web/check-deployed-web-blender.mjs", + "exitCode": 0, + "nativeObjectMutation": [ + 3, + 4 + ], + "wasmRangeStatus": 206 + }, + "sshReadOnlyInspection": { + "service": "blender-web-58014.service", + "active": true, + "entrypoint": "/var/www/blender-web/current/tools/web/deployment-http-server.mjs", + "packagedRuntimeFiles": [ + "deployment-http-server.mjs" + ], + "observedPostStatus": 405, + "allowedMethods": [ + "GET", + "HEAD" + ], + "connectionClosed": true + } + }, + "findings": [ + { + "priority": "high", + "code": "SERVER_OPERATOR_PROVIDER_NOT_CONNECTED", + "endpoint": "/api/server-operator-job", + "evidence": "POST describe requests for mesh.primitive_cube_add and OBJECT_OT_modifier_apply returned 405; Chromium F3 showed SERVER_OPERATOR_HTTP_FAILED: 405.", + "impact": "The configured shared provider path blocks SERVER_NATIVE actions; catalog assigns 1613 units to this path. This does not mean 1613 distinct operations were individually tested.", + "sourceReference": "web/app/src/engine-client/WebEngineClient.ts:387" + }, + { + "priority": "high", + "code": "BROWSER_ROUTE_SEMANTICS_INCOMPLETE", + "evidence": "From Modeling, SCREEN_OT_area_split switched to Layout and retained the same four editor areas.", + "impact": "Action-group classification does not implement each desktop operator. All 434 BROWSER_EQUIVALENT assignments require semantic acceptance; one mismatch was reproduced.", + "sourceReferences": [ + "web/app/src/app/App.tsx:167", + "web/app/src/app/App.tsx:3534" + ] + }, + { + "priority": "high", + "code": "BEHAVIORAL_EVIDENCE_REFERENCE_DRIFT", + "evidence": "183/373 directly referenced artifacts have SHA-256 drift; 902/1025 recorded verified units are affected.", + "impact": "Recorded VERIFIED counts cannot be treated as current release acceptance. Matching references alone also do not establish full behavioral parity." + } + ], + "limitations": [ + "This is a focused production smoke test, not a full Blender operator/property/context matrix.", + "Workspace tabs were checked for presence only. Render quality, simulations, animation results, node evaluation, add-ons, Python compatibility, large-scene performance and context-specific editing were not exhaustively tested.", + "The local F3 cube form was present with zero typed property controls; its PASS result only establishes form presence.", + "Final screenshots after workspace switching are observations, not a stable-frame visual correctness assertion.", + "No queue, historical inventory, completion overlay, production source or server configuration was changed by this audit." + ], + "artifacts": [ + { + "path": "tests/golden/WBV2-P1424-001/deployed-audit/browser-area-split-result.png", + "byteLength": 187298, + "sha256": "0e31ca29f519c50a1f6c5a91d1c8436bbb56efcff108b093af4e77797e09bb50" + }, + { + "path": "tests/golden/WBV2-P1424-001/deployed-audit/chromium-report.json", + "byteLength": 6565, + "sha256": "867e63b65bef497593fefcd5884f0666752b3c59f0d4e18354d1b64d7cdeef94" + }, + { + "path": "tests/golden/WBV2-P1424-001/deployed-audit/desktop-final.png", + "byteLength": 111507, + "sha256": "9eac6d31197eb681e237503bcc20a046e26b73c64bd7e737892a4bf74bb2edca" + }, + { + "path": "tests/golden/WBV2-P1424-001/deployed-audit/desktop-open.png", + "byteLength": 178549, + "sha256": "0ecdceb9b8b04fc3eb4d9fb752ab7746b26e2d974520a78ba6b81b7e1456639c" + }, + { + "path": "tests/golden/WBV2-P1424-001/deployed-audit/evidence-integrity.json", + "byteLength": 246111, + "sha256": "4de65962c7e1a4ea93b04d200e62dc4a4ad986424bc6503e39dd007ab0143ecc" + }, + { + "path": "tests/golden/WBV2-P1424-001/deployed-audit/f3-server-result.png", + "byteLength": 180454, + "sha256": "600f61e19edef7bb476113fec5b75c09845ce42b60fcf97343fce21668920980" + }, + { + "path": "tests/golden/WBV2-P1424-001/deployed-audit/roundtrip.blend", + "byteLength": 205638, + "sha256": "29f7f3f90e04454b47c2bb715515bb41badfa87e4b73e73e95345d5517222f90" + } + ] +} diff --git a/tests/golden/WBV2-P1424-001/deployed-audit/desktop-final.png b/tests/golden/WBV2-P1424-001/deployed-audit/desktop-final.png new file mode 100644 index 000000000..15aa88065 Binary files /dev/null and b/tests/golden/WBV2-P1424-001/deployed-audit/desktop-final.png differ diff --git a/tests/golden/WBV2-P1424-001/deployed-audit/desktop-open.png b/tests/golden/WBV2-P1424-001/deployed-audit/desktop-open.png new file mode 100644 index 000000000..e0dbbae41 Binary files /dev/null and b/tests/golden/WBV2-P1424-001/deployed-audit/desktop-open.png differ diff --git a/tests/golden/WBV2-P1424-001/deployed-audit/evidence-integrity.json b/tests/golden/WBV2-P1424-001/deployed-audit/evidence-integrity.json new file mode 100644 index 000000000..3aac80c14 --- /dev/null +++ b/tests/golden/WBV2-P1424-001/deployed-audit/evidence-integrity.json @@ -0,0 +1,7378 @@ +{ + "observedAt": "2026-09-08T01:29:54.544Z", + "scope": "Direct evidenceManifest and productionEvidence SHA-256 references from the current dynamic inventory; not transitive runtime or parity validation.", + "recordedVerifiedUnits": 1025, + "unitsWithMatchingReferences": 123, + "unitsWithReferenceProblems": 902, + "referencedArtifacts": 373, + "matchingArtifacts": 190, + "driftedArtifacts": 183, + "missingArtifacts": 0, + "references": [ + { + "path": "tests/golden/WBV2-P1107-000/manifest.json", + "expectedSha256": "a53ebdc52db5dcf27d44e938e5551f1ee2adae8e46c3fe8661604ee6b1000f8c", + "actualSha256": "a53ebdc52db5dcf27d44e938e5551f1ee2adae8e46c3fe8661604ee6b1000f8c", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1107-000/modifier-source-roundtrip-production.json", + "expectedSha256": "ceb8035fb83813683008e0caeabc5fcc9f33882eae7abb7036feafe680200a97", + "actualSha256": "ec9daecffb74e5c7ff0e02e98d5ae6fba3e7b6595bd2dd9772fe82bcbf429df0", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P11-002/modifier-parameter-production.json", + "expectedSha256": "80ed9b001c16db399b9078636bccbf4273636f837da8a9a4b9179273ae662dc7", + "actualSha256": "f21396a7194ef7f5601e85262ab09ea337fb421697017be5804f50fdff850fda", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1145-001/manifest.json", + "expectedSha256": "bf90f285d1ef5c5255ef1dfb99656ecc3c47118c035547ef2ac258c1a43bbc96", + "actualSha256": "bf90f285d1ef5c5255ef1dfb99656ecc3c47118c035547ef2ac258c1a43bbc96", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1145-001/corrective-smooth-production.json", + "expectedSha256": "2afd10cbf4101867ccd6857181d439b2fad4fe54471f5562c9c056a75d1456ec", + "actualSha256": "2afd10cbf4101867ccd6857181d439b2fad4fe54471f5562c9c056a75d1456ec", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1146-001/manifest.json", + "expectedSha256": "94c0399e25fe0323bf13a57359c020e6b70bf5dd66006bb0d69e4069e3a71c82", + "actualSha256": "94c0399e25fe0323bf13a57359c020e6b70bf5dd66006bb0d69e4069e3a71c82", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1146-001/modifier-reader-batch-production.json", + "expectedSha256": "4dd99944e5eec83d173c28ed9e205a96be0ae197ed37209d8b49f90c797d07d3", + "actualSha256": "4dd99944e5eec83d173c28ed9e205a96be0ae197ed37209d8b49f90c797d07d3", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1151-001/manifest.json", + "expectedSha256": "6d1f0bbcfa4116507e25821e63761b0c736c2283f73d82970ccad8a66014427b", + "actualSha256": "c6d4c9cbd777843c37dcdd2218494d895d8e3354e7ee867bace297fbe85895b2", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1151-001/modifier-reader-batch-production.json", + "expectedSha256": "7002b529658c1549228a4dbeebf58e634e41ba8309305ee5e47b0350a2ecfeb1", + "actualSha256": "7002b529658c1549228a4dbeebf58e634e41ba8309305ee5e47b0350a2ecfeb1", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1153-001/manifest.json", + "expectedSha256": "8d7804489e5238f749918d7c694b40e6aa1ee71b686cb617e7eda2ba880b3628", + "actualSha256": "2b54a6fb3557d5c156fd682d23677c8e6788811d5df22611a4437ca01044097f", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1153-001/source-dependency-reuse-production.json", + "expectedSha256": "de4dace6b06a305b11e9ee65c6e787c0b0304b1303b503c4fcdfe6c37f41dabf", + "actualSha256": "de4dace6b06a305b11e9ee65c6e787c0b0304b1303b503c4fcdfe6c37f41dabf", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1147-001/manifest.json", + "expectedSha256": "3f9df067f99cf6fed57b971d62ab38b07738d2e6ab9c24454bce14b6edf5d18f", + "actualSha256": "6c9d7b844434668b2614d7215e44c146f7adf081480ec71bff6d534d0df6dbce", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1147-001/modifier-reader-batch-production.json", + "expectedSha256": "bfd794257d3c739c026a52c6995b9cdcf1af892944eebf584937f772741edf94", + "actualSha256": "407b1f5e790547085af2197e1629d09fcd0637de13d5497fafffdc17877024cd", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1151-001/manifest.json", + "expectedSha256": "5a29e9bcf445b79d49cdba306a81a683e243e11164f28818c50b814d25e0b84f", + "actualSha256": "c6d4c9cbd777843c37dcdd2218494d895d8e3354e7ee867bace297fbe85895b2", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1152-001/manifest.json", + "expectedSha256": "cdaf821477bdb244a99d28cd8173394aaed20a7bc1e4f90a9a46ac67e600ac2f", + "actualSha256": "2aff8ed59d6c3455b3295ae29457047bfe2469866130a8670e44f0a4c676d03e", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1152-001/modifier-reader-batch-production.json", + "expectedSha256": "6fc2e91cf28b8d8e3a54182df4552c67b963a824d8d99967ddfc622186d4fdbf", + "actualSha256": "6fc2e91cf28b8d8e3a54182df4552c67b963a824d8d99967ddfc622186d4fdbf", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1150-001/manifest.json", + "expectedSha256": "3e915bcd02d5a506e7ed18213e834c5d9f73c1c44431808ced9ebb49a7c15697", + "actualSha256": "98df7f27ebf6575f81b96b89b92cdb6016122f5a0e5470a8fd039eb30e2a6d9e", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1150-001/modifier-reader-batch-production.json", + "expectedSha256": "ed20f7958b7242be8459c23985e022c83d791d4ff966360a3f29cad0f8d6e824", + "actualSha256": "ed20f7958b7242be8459c23985e022c83d791d4ff966360a3f29cad0f8d6e824", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1149-001/manifest.json", + "expectedSha256": "ff6441bbcf52bcdfe898cf2b90d287969dd43edb07dc50d2ed56fd95d665d000", + "actualSha256": "1f031db52009e862852f802cb4273ec53e5b1c004fff7bfd0e469cbaf65a64c4", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1149-001/modifier-reader-batch-production.json", + "expectedSha256": "0f3675f85939e421658e324c39e43954371d9d740dd3ca78e713fca38d452e4c", + "actualSha256": "0f3675f85939e421658e324c39e43954371d9d740dd3ca78e713fca38d452e4c", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1148-001/manifest.json", + "expectedSha256": "82ed070c23f0aef0ae1f66612cd213bf1af2d8f53095c24e8d1e0235bef268f8", + "actualSha256": "3602227697c22e05550370215e38b30cdcc4e9fd27a2f8a1fe8842f85cdbed69", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1148-001/modifier-reader-batch-production.json", + "expectedSha256": "560a4b2eae1fec4dc85acf138bf7dd85825643aadb1dcb71acb4788d433a733c", + "actualSha256": "560a4b2eae1fec4dc85acf138bf7dd85825643aadb1dcb71acb4788d433a733c", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1162-001/manifest.json", + "expectedSha256": "6b60a74ee4663a1b1135ade2ad3a8ee8a77825d8e2aa743b181fe1ec2ea5083a", + "actualSha256": "7b4fa8bd4c9fa3a52249a189e02379c86a95c3e65f183a494d7aeb6cc0866d85", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1162-001/shape-key-reader-production.json", + "expectedSha256": "e2c44c4a4c54ad137532a2c1884ca4842a9c1d0bfefde236b17af56518df277f", + "actualSha256": "e2c44c4a4c54ad137532a2c1884ca4842a9c1d0bfefde236b17af56518df277f", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1154-001/manifest.json", + "expectedSha256": "6e4fca42c3ae3f7cc8a810d751bdb3d116194f82625e0d0d6bef23dded40ff5f", + "actualSha256": "458825d12b8d663852f5b9be986027eb06d2d87791084924c1bd2d2b696258e6", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1154-001/modifier-reader-batch-production.json", + "expectedSha256": "adfd3c493a357c2742960390cf5b282e4193d4aa96e40fa34487a6df23f0da1e", + "actualSha256": "adfd3c493a357c2742960390cf5b282e4193d4aa96e40fa34487a6df23f0da1e", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1117-000/manifest.json", + "expectedSha256": "7a924cc4bd9bca8966039314fcee7cbab5c09fed0daa40d0e6d14fb715cd5423", + "actualSha256": "7a924cc4bd9bca8966039314fcee7cbab5c09fed0daa40d0e6d14fb715cd5423", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1117-000/physics-manifest-production.json", + "expectedSha256": "34234500e77ef98951c8861459a3a10c8d67ea674ddb30d3bbf6c3b84808aeb7", + "actualSha256": "0b299fbcbf72052078133d0d0ac6ff496283d32d8bdca3856c9d9aa0b36ad118", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1156-001/manifest.json", + "expectedSha256": "d10fca9f8f35e1af8bddbdfba7eef5cbe67102263da1e60fe36f1d9844a8aedc", + "actualSha256": "4eb937dca6cb1b99938925bd983d99a01b089f48a14586246b7834114abde767", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1156-001/modifier-reader-batch-production.json", + "expectedSha256": "8361cf72da89ca02ea8c117055634156e782d4a53daaf53b0716d68d3427be87", + "actualSha256": "8361cf72da89ca02ea8c117055634156e782d4a53daaf53b0716d68d3427be87", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1164-001/manifest.json", + "expectedSha256": "224355803b42d29f3461605f41f1ecaab47b64298a9fa79fc7d194045f7fbb42", + "actualSha256": "4650c7bfcf7a5bbbdf7b6cd089657ae60a0eb6b8f72c5ff3eacd5319d63db6c6", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1164-001/compositor-main-reader-production.json", + "expectedSha256": "968cf4db7951a790d72958231ba6a903041ac39a53b726d0930f12e64f6f8ab2", + "actualSha256": "968cf4db7951a790d72958231ba6a903041ac39a53b726d0930f12e64f6f8ab2", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1165-001/manifest.json", + "expectedSha256": "4e1a9eb563dc8787ba00a58e1c1d25509de658519892aac2d42b345576e34083", + "actualSha256": "c6a58932c81c8458147c3ddd45e7f7e31f617a2e352652bb3d1fec46c4f1506e", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1165-001/compositor-main-reader-production.json", + "expectedSha256": "a926e6db40ed9d62edf2df08ba4047a19107365890925f101f962e0e1dab3faf", + "actualSha256": "a926e6db40ed9d62edf2df08ba4047a19107365890925f101f962e0e1dab3faf", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1166-001/manifest.json", + "expectedSha256": "c1685b84666189d4c56a0dd421bb16f4431d4ab8a6716811a647a81e7e234721", + "actualSha256": "7adeebd69ec2406809cbaa590f371191fac07d69cc4727ad0f0b55017f5d6cfe", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1166-001/compositor-main-reader-production.json", + "expectedSha256": "afaa9a06e075d5bed49eb69fb01f245000404bc2fbde1fdbec3e16249c395763", + "actualSha256": "afaa9a06e075d5bed49eb69fb01f245000404bc2fbde1fdbec3e16249c395763", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1167-001/manifest.json", + "expectedSha256": "1828f5bffb8b0b210682f08f2476c03786ca1db522d50d50fc64182b4b8c2a4a", + "actualSha256": "bd8c3000b622013af23120a0d8ed69ea6387ad87959b172c41c3bb0bb47493ca", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1167-001/compositor-main-reader-production.json", + "expectedSha256": "7d9b816ec833e7220dbc81af25d5debf01cdc0f2ea85d32b3a0f46686ff461fc", + "actualSha256": "7d9b816ec833e7220dbc81af25d5debf01cdc0f2ea85d32b3a0f46686ff461fc", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1168-001/manifest.json", + "expectedSha256": "f6c159d3e0283ed28847706276bd010eafb82efd31028341eef44785ee7e90a6", + "actualSha256": "9e9777917e27b0b1cf5bd13de6bb13327afdc26a934cc6335b0ba0b268975c0b", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1168-001/compositor-main-reader-production.json", + "expectedSha256": "e93507f8474e0b7b39b2330bba890f65a34625f14de54f1d4419b56f23ad9387", + "actualSha256": "e93507f8474e0b7b39b2330bba890f65a34625f14de54f1d4419b56f23ad9387", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1104-000/manifest.json", + "expectedSha256": "07adf9ad7a4296f771b4d2759005889214b31767018b2a205212ec8362afd95b", + "actualSha256": "07adf9ad7a4296f771b4d2759005889214b31767018b2a205212ec8362afd95b", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1104-000/compositor-main-reader-production.json", + "expectedSha256": "4e6ba035d313e6f83c0205ab6f9e82a8320e6046b62e7b9d113c0d001d4a22f5", + "actualSha256": "7212e2d71f5a6da5e80c2978a6a0d4d73d60f271080e41b55e1cded22851a49c", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1169-001/manifest.json", + "expectedSha256": "d39213f6101c460963b1dd515a76cbfb51461d05c6612be479b6f62d23c5de9a", + "actualSha256": "bff38cea67a05f75bd7b5721da87bcb211137265acd51f70973379730ee6f2c1", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1169-001/compositor-main-reader-production.json", + "expectedSha256": "fd6c339e9d234aeb929db4fe4b5fe50fc0dcb584dfff097604cdc90f5a739784", + "actualSha256": "fd6c339e9d234aeb929db4fe4b5fe50fc0dcb584dfff097604cdc90f5a739784", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1163-001/manifest.json", + "expectedSha256": "5a76ab54ce7794b08f28459b7cb6ad7aa17f246d68a3b0639aac7eddfef03225", + "actualSha256": "fcac7bc15d6302bf018578cf7017100b62770a73ed09c75cf2154e670d489cc4", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1163-001/compositor-main-reader-production.json", + "expectedSha256": "67f33ccfc75dd28804c28a35b6c6e506b7e3bb489d7e4f70db4d10473bd20a76", + "actualSha256": "67f33ccfc75dd28804c28a35b6c6e506b7e3bb489d7e4f70db4d10473bd20a76", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1170-001/manifest.json", + "expectedSha256": "fdea527ad3b171459363ce48ff2d1ee2d52d98e2ac6bbce4172e2712bad1fc85", + "actualSha256": "fadbdc8e186772ab2dce0bbd3b59edf6fe39bb684eebd82fc4624de6372344eb", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1170-001/compositor-main-reader-production.json", + "expectedSha256": "76da1f6a141c427e9d461c256a1801e09b9ca7947fe94d1b6566f2ae0e040730", + "actualSha256": "76da1f6a141c427e9d461c256a1801e09b9ca7947fe94d1b6566f2ae0e040730", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1171-001/manifest.json", + "expectedSha256": "92994b80f5d198f71cb069dd892ba2d94b2d6ae1ecfe22938f5c4b8ff4403f59", + "actualSha256": "206df288ff26e85c7a1abab00fd47cb7ddd2eed13103326daffbcf1d7b56aba4", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1171-001/compositor-main-reader-production.json", + "expectedSha256": "c47fdbee47b51888e3bdff5b2eef8a71e62962893718cc6495a8345b5a6a3e72", + "actualSha256": "c47fdbee47b51888e3bdff5b2eef8a71e62962893718cc6495a8345b5a6a3e72", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1172-001/manifest.json", + "expectedSha256": "384e2da06930cb03abbd6fad2ddf569bbec516510781c2e1ec9cdf0c031b4ab8", + "actualSha256": "ce25a466033d953f7b8e1d753291362139f44561bb2a9239a788941387837f9a", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1172-001/compositor-main-reader-production.json", + "expectedSha256": "dbabf06933e99411a8ec23eeea2b1484eac9e049c4ecd300081bd248ab7491d9", + "actualSha256": "dbabf06933e99411a8ec23eeea2b1484eac9e049c4ecd300081bd248ab7491d9", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1173-001/manifest.json", + "expectedSha256": "66c8a833744d75df9795aae80e4f21db5ba44e7ffa95ef8b32acfab240d5335a", + "actualSha256": "20301e426993ec0ed89e4ba4b704335bdbcd8416e37716efc1d12b8ba7b41c68", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1173-001/compositor-main-reader-production.json", + "expectedSha256": "73cdbbe4547df60e55076235ab32cf258ac840a64f48861f7b5d12648fc3de66", + "actualSha256": "73cdbbe4547df60e55076235ab32cf258ac840a64f48861f7b5d12648fc3de66", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1174-001/manifest.json", + "expectedSha256": "e082e4a53908818b0345406d85b1038c81e68910ba786be82f81a3c0ce3c9326", + "actualSha256": "1c38c1eba5b819e84a817e05980ff04735721f6a4bb819e92a2ed7d00a6115c2", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1174-001/compositor-main-reader-production.json", + "expectedSha256": "5aa23d41828df48fcb721b07783d94c0701a146d06331e9b908c3e8effe0ad28", + "actualSha256": "5aa23d41828df48fcb721b07783d94c0701a146d06331e9b908c3e8effe0ad28", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1175-001/manifest.json", + "expectedSha256": "5ce4f613c046dd4edd919060fccfbe7b202498db7a1e5651350dbcceadb4b7a0", + "actualSha256": "9d084548eb70bf03991346568321d666ce00ba0bc05745084e414e781a2d03cd", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1175-001/compositor-main-reader-production.json", + "expectedSha256": "d213320f64d962b610159ada32e6c8ecefe5172de49e43c0dc816619263c108e", + "actualSha256": "d213320f64d962b610159ada32e6c8ecefe5172de49e43c0dc816619263c108e", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1211-001/manifest.json", + "expectedSha256": "c573250cd77db92dde2e5cd84c0c12910e0a7c4a3466d765dfb0a8ccd3c2f9e0", + "actualSha256": "f87a9f3b09c2aed8820eb88c41ee19a2b74f52e7c8e7fc365fb19645ce9a512c", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1211-001/geometry-node-reader-production.json", + "expectedSha256": "b46f9c846ad232d5d543bc24c6a6873f166d0a7744ff21533e60a01867d51b4a", + "actualSha256": "b46f9c846ad232d5d543bc24c6a6873f166d0a7744ff21533e60a01867d51b4a", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1212-001/manifest.json", + "expectedSha256": "382d5cf536a4fbb1fb998c82f8fcb5d51e2d802231cdca4858671a98eda9368d", + "actualSha256": "5d07c160b79141fd75496345b6da0011330f28ae032f816fc3e16c02eaec2fa7", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1212-001/geometry-node-reader-production.json", + "expectedSha256": "37675fa68bc775c928441c988c731259d543d51d77c0354fe4d00702c60dcb03", + "actualSha256": "37675fa68bc775c928441c988c731259d543d51d77c0354fe4d00702c60dcb03", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1213-001/manifest.json", + "expectedSha256": "468b536066f26b22cc6452bd35d63879f22dfb6f60dc595a850175809f7e2bcf", + "actualSha256": "5202591a1ca7fc28d7064db5a6f847f456ab769702aef58b5723ba3851d0dd46", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1213-001/geometry-node-reader-production.json", + "expectedSha256": "501f51bf987f77858615235d139d4083e8f1af06c1bfec4f227034d371b18a00", + "actualSha256": "501f51bf987f77858615235d139d4083e8f1af06c1bfec4f227034d371b18a00", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1214-001/manifest.json", + "expectedSha256": "b02d0cbd7972bf1a6ad4cc3ca18f79f2dad102b52c1f3b2823059eaa75544956", + "actualSha256": "c219451b5a1f675c8b5d852feef3c4053285b1c5b46a218c054d9dd0c794fc1a", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1214-001/geometry-node-reader-production.json", + "expectedSha256": "4827d2a393e8f86c8a221fb1673248b58d21b68da459f6dee5a49957207365c6", + "actualSha256": "4827d2a393e8f86c8a221fb1673248b58d21b68da459f6dee5a49957207365c6", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1215-001/manifest.json", + "expectedSha256": "0145dc279f629dd92c55103c10d3e95f3a282640b691fd76b2e59f29a299546d", + "actualSha256": "1ca8f8120828c563b0bcdf1830a713b89c292028ea14381dd8ce7b8b98ffcec3", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1215-001/geometry-node-reader-production.json", + "expectedSha256": "4f0abb32228bb5ba6d720f1b49bc1e9d0bfe2f13cc912be3650b4f3ed3b05eec", + "actualSha256": "4f0abb32228bb5ba6d720f1b49bc1e9d0bfe2f13cc912be3650b4f3ed3b05eec", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1216-001/manifest.json", + "expectedSha256": "a0ef63345ecb428d5febbd02236221fd8958422fcc049349a8eb65b81d534793", + "actualSha256": "e0a7c9136330a3f690a76877b882fe545609cbc3ca6b7856a01731011c68d947", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1216-001/geometry-node-reader-production.json", + "expectedSha256": "6332804a8178f0333cad8f9e0f266af8785a6bf2d22cbf9865f019af9a7e134d", + "actualSha256": "6332804a8178f0333cad8f9e0f266af8785a6bf2d22cbf9865f019af9a7e134d", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1217-001/manifest.json", + "expectedSha256": "6921dfe4c18e91f7e1a637a7a16d937c9a9b6563f0520d6d5aa427bfffd46774", + "actualSha256": "e7a510ecc9c53a878c244d0d1ae315ad100b27408654d408b5e5059026663360", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1217-001/geometry-node-reader-production.json", + "expectedSha256": "6fd52cae78c377da8cef6d632aaa678e743f5c79d5bb1441c50448b0b06e20c4", + "actualSha256": "6fd52cae78c377da8cef6d632aaa678e743f5c79d5bb1441c50448b0b06e20c4", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1218-001/manifest.json", + "expectedSha256": "5024e7c83a2dd564911044bb198558f7af3df25e33a76ae9411da1fce6c21635", + "actualSha256": "f143b648cb8d77ca5e15e3bebd7cede9df2ae4710dbb764fb03cafccccb2e281", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1218-001/geometry-node-reader-production.json", + "expectedSha256": "d33707f0ab5748582a498089122c998d6bac88d8087e31a86e96a81930b39e2f", + "actualSha256": "d33707f0ab5748582a498089122c998d6bac88d8087e31a86e96a81930b39e2f", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1187-001/manifest.json", + "expectedSha256": "60f8ca5afd02084023cb3698fd88326aa25ca9912b7ac24c6c19b06e785ca078", + "actualSha256": "72f24e9be70e6db4d000dd6ffcf5f129359acf1a3afa449a3f179772041e218b", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1187-001/geometry-node-reader-production.json", + "expectedSha256": "dd9dc9355b95872ce2ee7fc5cfb08fa56111d36fa9419f69e961b4f495b8d92c", + "actualSha256": "dd9dc9355b95872ce2ee7fc5cfb08fa56111d36fa9419f69e961b4f495b8d92c", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1188-001/manifest.json", + "expectedSha256": "a6fdb39cadcc6eb4cb3ede0071bec013249462ec871dd08520eee30c7ccfcc01", + "actualSha256": "afa9c5f4d5f65eca219b05f94b5a3880fc89c4bf20d04b698ff63ef4ec4ca960", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1188-001/geometry-node-reader-production.json", + "expectedSha256": "18db62916aa700acbb0363c6072288d811a69552c4fe7156f66ccafc038ab7ef", + "actualSha256": "18db62916aa700acbb0363c6072288d811a69552c4fe7156f66ccafc038ab7ef", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1189-001/manifest.json", + "expectedSha256": "a0fccd14f3aa8d6cc419038e0d14f9dd8dcadac8c7003429cd502010cca176c1", + "actualSha256": "115310638a85dc0980ee4b4c5b0763c45f8ef8e8d27f3349a358047846b1affd", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1189-001/geometry-node-reader-production.json", + "expectedSha256": "9fb76e881cd0e65ee11dc0b2647750ad498257e8fa8faaa6de0cf26a7f453b75", + "actualSha256": "9fb76e881cd0e65ee11dc0b2647750ad498257e8fa8faaa6de0cf26a7f453b75", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1125-000/manifest.json", + "expectedSha256": "bbc4bd63d775870cd78a63e41a6945126ff628437a44f60d49b2cbb6e84c4d0e", + "actualSha256": "bbc4bd63d775870cd78a63e41a6945126ff628437a44f60d49b2cbb6e84c4d0e", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1125-000/geometry-node-evaluator-production.json", + "expectedSha256": "7a5bc81aaca3e4a50219cefb8486db94682a777dd2010aa0b70b69e3b9bdf59e", + "actualSha256": "7a5bc81aaca3e4a50219cefb8486db94682a777dd2010aa0b70b69e3b9bdf59e", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1190-001/manifest.json", + "expectedSha256": "218ebd41329bc299303987017789c9e7bc3764e4c1f5743914b3d766c5564330", + "actualSha256": "ffbb6efb39db25c1b55f4b03befe1e45b50f2a35dd3bb7910184594da59753a6", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1190-001/geometry-node-reader-production.json", + "expectedSha256": "68418d25537c0ff37b2bef6a7aba4e0170306e631becab661be1a3970fec3f04", + "actualSha256": "68418d25537c0ff37b2bef6a7aba4e0170306e631becab661be1a3970fec3f04", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1191-001/manifest.json", + "expectedSha256": "9e196cb8f0b7b242748ea83cac6b98627f3077706575a9441f5eaa8fbebb787e", + "actualSha256": "c4fa52ba137cf2ead6e181cea797c7d8991e347b2e99f2a2c3530147cdeb2654", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1191-001/geometry-node-reader-production.json", + "expectedSha256": "08a36b2ffb330fc6b85ae8ed8ef00bdb141e1b10ba71bd68d04d0d948e2d4e51", + "actualSha256": "08a36b2ffb330fc6b85ae8ed8ef00bdb141e1b10ba71bd68d04d0d948e2d4e51", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1192-001/manifest.json", + "expectedSha256": "29c907f088d77abd84906cbc46d7e4ca2bcd186eab8f9e41bf00ac0d2fe1beb8", + "actualSha256": "84b1fbd0b310f6e19b7fc37cc90737d95718e1c90af7e74d1dd2c38a85ac2b11", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1192-001/geometry-node-reader-production.json", + "expectedSha256": "aa74b062e9b77f400ab8fc2fb5d8ac9853c5e3401d2acb4a3e397f9d163b4019", + "actualSha256": "aa74b062e9b77f400ab8fc2fb5d8ac9853c5e3401d2acb4a3e397f9d163b4019", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1193-001/manifest.json", + "expectedSha256": "8d01506c83fcf79e9992942f431dc53a18e84773b103668964140f29c01ec3a1", + "actualSha256": "e30ec0d6e91f0035005f1852033684ed2752b8d3e55d6680260a31dd82e53f53", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1193-001/geometry-node-reader-production.json", + "expectedSha256": "b82a10f084560da8fecca75d1d7d11a8a242bd945e61c872e359690e41b04e08", + "actualSha256": "b82a10f084560da8fecca75d1d7d11a8a242bd945e61c872e359690e41b04e08", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1194-001/manifest.json", + "expectedSha256": "623ec2a5756214dd84c1880fc9221bdb7fac895fa3cbc4d4ba10dd05e9317d90", + "actualSha256": "4cff59e2a1fae48a96240e48d0baf6cccfe0f05d04e6f95383ee93160980eb40", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1194-001/geometry-node-reader-production.json", + "expectedSha256": "40ddd47c3c107289fc9866a4f013f0473931005cd3d642d23daf82561b64fbc9", + "actualSha256": "40ddd47c3c107289fc9866a4f013f0473931005cd3d642d23daf82561b64fbc9", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1195-001/manifest.json", + "expectedSha256": "221b02f499865978d3132ddaa8b200f9da8072cce37fc0577b1e0d4797683518", + "actualSha256": "6e3f7a2613d2422ca9af148973c6f475ff5e3919070a8d980c4795a7a1356a32", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1195-001/geometry-node-reader-production.json", + "expectedSha256": "4ba3415ce3a8bdaa051c5b8f739487680fe98b98d9b5330616d55fe9f9332f4b", + "actualSha256": "4ba3415ce3a8bdaa051c5b8f739487680fe98b98d9b5330616d55fe9f9332f4b", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1196-001/manifest.json", + "expectedSha256": "b0e0ffa6b2934d082fc05af0cf3465841d5032b5b38e356c8ac9fc288b7aa61d", + "actualSha256": "0402490b4837886eb3eeea57caa717621d9cb5dbaa1821352db10c88ca28e34c", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1196-001/geometry-node-reader-production.json", + "expectedSha256": "7cbf1dbf3f3b50d6dac9b38e313aacbdf3311933b0f457611936395399de1404", + "actualSha256": "7cbf1dbf3f3b50d6dac9b38e313aacbdf3311933b0f457611936395399de1404", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1197-001/manifest.json", + "expectedSha256": "fe7f2d48edbbb8064a347dbcbd9c277debab6e6aec2ba6110658fd56bc350cd7", + "actualSha256": "90c3865bb1e54b8803645b8f4099f2640575cd7b0d5028f8b76187cc4031bed0", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1197-001/geometry-node-reader-production.json", + "expectedSha256": "1f370f49f58350a27513ca4a200c6c8f3875714212c2b698db548678fda9271e", + "actualSha256": "1f370f49f58350a27513ca4a200c6c8f3875714212c2b698db548678fda9271e", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1198-001/manifest.json", + "expectedSha256": "ad3318680b965d54a620d3da553eee0d1a2b10d2accc2bf5799e77905e18ef9b", + "actualSha256": "f1e8042785bccb1e049d0d2755689df096429d97fd3f580c563ae58ace40cd39", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1198-001/geometry-node-reader-production.json", + "expectedSha256": "4d8f893ad3785c222397fa00cbac4a4914ba8ac8fb5ffb6314f4fe5fe490b1e3", + "actualSha256": "4d8f893ad3785c222397fa00cbac4a4914ba8ac8fb5ffb6314f4fe5fe490b1e3", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1199-001/manifest.json", + "expectedSha256": "a4c2fd1e195ef6c387a951b5953fc88723751d6a57289b8608f605849aae1add", + "actualSha256": "f9c95ff34bb6fcee59f09e8fa1e5bc2019ede1280ae12733eaeb9ca3116313da", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1199-001/geometry-node-reader-production.json", + "expectedSha256": "fd5cc7e2e2f496fd0aeb24d158f897d31ab69920653c72d8d848764a0ba3f2da", + "actualSha256": "fd5cc7e2e2f496fd0aeb24d158f897d31ab69920653c72d8d848764a0ba3f2da", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1200-001/manifest.json", + "expectedSha256": "be4b2fa4025d0c1adbc5ff6cef99ec9dcfe5887df591f88c3d2895fb5d24337f", + "actualSha256": "d55d40d5d89d1110680b30c72607bc378870558ef7023d25f988ce15c241afd7", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1200-001/geometry-node-reader-production.json", + "expectedSha256": "8623baea43ce150415ce9fa30b900b30f9edacb6a462c74e91b47f206798bf46", + "actualSha256": "8623baea43ce150415ce9fa30b900b30f9edacb6a462c74e91b47f206798bf46", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1201-001/manifest.json", + "expectedSha256": "3290babea297ceacc38602e8ed10f93646d8afae433c6ba347f3ddea1b49c3ae", + "actualSha256": "4cd3a2ec919cd9d52c0d50001e011f6540759a27a0bf2f0706165e6220f377cd", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1201-001/geometry-node-reader-production.json", + "expectedSha256": "b9f25213453c378df35a3096c50316b3afc6671dd0c6482a93340c014189086e", + "actualSha256": "b9f25213453c378df35a3096c50316b3afc6671dd0c6482a93340c014189086e", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1202-001/manifest.json", + "expectedSha256": "c4c4974c6d2e459ac861c2001ea3b4193dfdd5e0ea25da996f507afbddde81eb", + "actualSha256": "e02eb6b7d264ffad95e57c467061fc0025c69bedf3011c82e421f2000e74ac30", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1202-001/geometry-node-reader-production.json", + "expectedSha256": "b2c88eee8a41ca53ddd45dacb74d47d0e3528789f10026eb9bdd0861c6defd58", + "actualSha256": "b2c88eee8a41ca53ddd45dacb74d47d0e3528789f10026eb9bdd0861c6defd58", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1203-001/manifest.json", + "expectedSha256": "7c36b74e9b2a16d1c26de9e3309461eead781426d3f69a31e5f5b3a58b552a6a", + "actualSha256": "ee203dad56ad1a7658781b1c90e8bf7d5878d35d8940c39bb0409b2e3d68e259", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1203-001/geometry-node-reader-production.json", + "expectedSha256": "ebb3f2be4f254787534abff8380ca64d52787135230c8f88885aec833cb6efa6", + "actualSha256": "ebb3f2be4f254787534abff8380ca64d52787135230c8f88885aec833cb6efa6", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1204-001/manifest.json", + "expectedSha256": "f78adf79bcacff704d011f9f8d03543ec3ba49318c04fcba1539721edee4eaa1", + "actualSha256": "457f3687faf5f1426947a9f759d67ddd7da0e3118f1834ba6279e471c5482579", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1204-001/geometry-node-reader-production.json", + "expectedSha256": "feab31229a002d95e9932cd9443dfc24414574eeca43853024ca91429670ecfc", + "actualSha256": "feab31229a002d95e9932cd9443dfc24414574eeca43853024ca91429670ecfc", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1205-001/manifest.json", + "expectedSha256": "d8ded778574463678ef16c215c658b8777b99d41e8d717b72afb100a14e90211", + "actualSha256": "94e1b0bb5acfddbfb967764f727aec689b1ccbaadccaa31eb38ffc0931a67e40", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1205-001/geometry-node-reader-production.json", + "expectedSha256": "1b5403eca14693ae27fdb5407b118b3b7521152b5753789ca2d5f0c9bc0b1cc4", + "actualSha256": "1b5403eca14693ae27fdb5407b118b3b7521152b5753789ca2d5f0c9bc0b1cc4", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1206-001/manifest.json", + "expectedSha256": "895f0223b7b0383c42b06b3d5b34a54b1df5800f32e77769554cea5bc51f8ba1", + "actualSha256": "5bd8edf018b9b885d294b064f2ba00f30718b5ea4b4a7afa841752628d3eaf62", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1206-001/geometry-node-reader-production.json", + "expectedSha256": "891f4d1f85b59c2a7f3d1819cb0ddf7b86c7b85715b41bcd3fe4a6a9586805a3", + "actualSha256": "891f4d1f85b59c2a7f3d1819cb0ddf7b86c7b85715b41bcd3fe4a6a9586805a3", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1207-001/manifest.json", + "expectedSha256": "5c25163da06171cda436ec99076de31e85ab331bcd5786fd6a052470d666efc5", + "actualSha256": "7bde1a4b5dda03d643e8869772a5a12ea7553c90856e7c045a0368b0a818664a", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1207-001/geometry-node-reader-production.json", + "expectedSha256": "8804f5d0301a217ecf1599f5ce93ddf6af03ba489e474e6f53b82fd251d7cb5a", + "actualSha256": "8804f5d0301a217ecf1599f5ce93ddf6af03ba489e474e6f53b82fd251d7cb5a", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1208-001/manifest.json", + "expectedSha256": "c1f58f808bc5d199e8849138d2b8eed06195e63f1e8035748c030e03c254dfc8", + "actualSha256": "e1fdb93f7c2cde6b0d26d6e38db4872c03b095424313399c1ffa1ee73063691a", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1208-001/geometry-node-reader-production.json", + "expectedSha256": "d48409ba9a106801082155ba581d890bdd85f432b82db696902a12be948d41ed", + "actualSha256": "d48409ba9a106801082155ba581d890bdd85f432b82db696902a12be948d41ed", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1209-001/manifest.json", + "expectedSha256": "5f3c03708c9b4f00e23cc74102c3b5a7687c7e4fa60b9aa2a7f71b231ee94232", + "actualSha256": "ad9b9e9f6a05ea70aa926b6d010fe3ee46078156fae8efe45c1b8b3ce536c796", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1209-001/geometry-node-reader-production.json", + "expectedSha256": "bfd7971b1aa623b3c9ccfcd2d514ef3022f3b98e0607240ecb5481ae8981cba5", + "actualSha256": "bfd7971b1aa623b3c9ccfcd2d514ef3022f3b98e0607240ecb5481ae8981cba5", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1210-001/manifest.json", + "expectedSha256": "f21e3d690637e1f006cae070e9d6465de448362dd741d8fcd12c66fc10cee35b", + "actualSha256": "dcebe11938211b829b82d6e189a114b54b5b3ff809523f5f828c00ef11e34741", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1210-001/geometry-node-reader-production.json", + "expectedSha256": "f0874db4251888711dde0982ab8554713a2499872e39fb85c40da301746417a6", + "actualSha256": "f0874db4251888711dde0982ab8554713a2499872e39fb85c40da301746417a6", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1219-001/manifest.json", + "expectedSha256": "ae3024f98470f75c57659063279a0bb208c8233965eb16339d8315fff87c31de", + "actualSha256": "bd862a88b4f36da53e39a3636ae3b1e758375861f74f39c9bac5a1fd2a914c31", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1219-001/geometry-node-reader-production.json", + "expectedSha256": "8c05358ca9f443fe933ed038127fb8435a6408ce03508ecd95cb1a6f08a2bd3c", + "actualSha256": "8c05358ca9f443fe933ed038127fb8435a6408ce03508ecd95cb1a6f08a2bd3c", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1220-001/manifest.json", + "expectedSha256": "9585dc791d7b59a21e54110b272a6dbdbbd25904133017434ea5ccdd901f1095", + "actualSha256": "667972d75bc608d5b2444e8457e7f127cbaccbbfb0beddadbf9cb3b0244e8b64", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1220-001/geometry-node-reader-production.json", + "expectedSha256": "1bdae83d3d44ea7831aa86c23124f73218e9019f4cbb8692e1ceb36bb20095fd", + "actualSha256": "1bdae83d3d44ea7831aa86c23124f73218e9019f4cbb8692e1ceb36bb20095fd", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1221-001/manifest.json", + "expectedSha256": "91215c270f181633d74a67020d45a24db2c2a633ec824c042b518c9edbf97519", + "actualSha256": "1f245d2df25fae908d366832bdb5dd8c6cccc63046e1e7aaf1919833542b990c", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1221-001/geometry-node-reader-production.json", + "expectedSha256": "b9afde1316b61c613fd83f29019eae1ae4a02714659c02daf982c657422e12ec", + "actualSha256": "b9afde1316b61c613fd83f29019eae1ae4a02714659c02daf982c657422e12ec", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1222-001/manifest.json", + "expectedSha256": "62aba60d2fee9f3c91b01e1a387f80b29d253ce9bef7819bf0eee2aa4fffe34c", + "actualSha256": "68698fb398d1c930c13334ebab60d8c7e654dd4ec0ad85f673a02d0cb0b31734", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1222-001/geometry-node-reader-production.json", + "expectedSha256": "d78baf531032cfc6f8753b2e48a5affdadfb13f459d0e7fb83b6ae06b6edde64", + "actualSha256": "d78baf531032cfc6f8753b2e48a5affdadfb13f459d0e7fb83b6ae06b6edde64", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1223-001/manifest.json", + "expectedSha256": "a0739edbc8fe0b1a018978e05a9d1d613c96c01eef1b50d300fd4195c0e0e0da", + "actualSha256": "7bc0f450f42b80061aaa0325d5060201502afb97d888c71a4c3d164061ea36bd", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1223-001/geometry-node-reader-production.json", + "expectedSha256": "ec09261083ee9eaf1e811ccc817f0a927db1f363a8c3ca3cfa2542418b0b0504", + "actualSha256": "ec09261083ee9eaf1e811ccc817f0a927db1f363a8c3ca3cfa2542418b0b0504", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1224-001/manifest.json", + "expectedSha256": "7b7febe8c87936d1405d0a3f9bc0f78fb42500abb0006d51cebfff5c45d66696", + "actualSha256": "1a4abbbe8d667a7fd27d0d6a54f0086784ab5309ea85be6d96d6c358af875c8c", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1224-001/geometry-node-reader-production.json", + "expectedSha256": "dff682ebc89b05274cf55970a6af004673b4c7aca3e2a0870bb9a7617384df2c", + "actualSha256": "dff682ebc89b05274cf55970a6af004673b4c7aca3e2a0870bb9a7617384df2c", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1225-001/manifest.json", + "expectedSha256": "abb3b977a3e502661ed6d4cf2e90e931da6b9e92c7b9166c26d2132a13fb5a2e", + "actualSha256": "acd6fc0d7d432d4b5db73af0864b8b9d5f3a5bf992c24223e4743e416ca2c852", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1225-001/geometry-node-reader-production.json", + "expectedSha256": "14e19f915b2e75c8f7e2ca54fd4e718cc40fe93db16104e9912e6f6ef04aa094", + "actualSha256": "14e19f915b2e75c8f7e2ca54fd4e718cc40fe93db16104e9912e6f6ef04aa094", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1226-001/manifest.json", + "expectedSha256": "e08957fe4d39c5ef1b4e09a1e5ea65336b75b9308c5e3017da17e2fbc501a4cd", + "actualSha256": "3ecae15d911489e02d24e2c68a380ac5a5b3df078a106829ddcc103e60ef8d6b", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1226-001/geometry-node-reader-production.json", + "expectedSha256": "a59786b44b7749dc16ef2301cd033b8ca8b9350e72cdce205eb259aa1fbc3839", + "actualSha256": "a59786b44b7749dc16ef2301cd033b8ca8b9350e72cdce205eb259aa1fbc3839", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1227-001/manifest.json", + "expectedSha256": "a1cd63e424c4c7b73ec5e5056a0bbae13448ffdde0034414123600d710b65732", + "actualSha256": "e3b737cbfda51bf28e993a0e4d236cb11f6d802f6579969ffca91b424237fba3", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1227-001/geometry-node-reader-production.json", + "expectedSha256": "a7e1d13a23b30b7ec5af37e5b76945808c4ca3a24fd93366504b4cc5f527bea6", + "actualSha256": "a7e1d13a23b30b7ec5af37e5b76945808c4ca3a24fd93366504b4cc5f527bea6", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1228-001/manifest.json", + "expectedSha256": "d47e5e0b1c37e50e48d79ae7dce4c1272feeb2c731c2c78f9d3e398838798cfe", + "actualSha256": "4fa3cb48c9bd9997609467f6f3cf313cef9fb9998ed690c6ac1f7e05d25b4d87", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1228-001/geometry-node-reader-production.json", + "expectedSha256": "db0aa6a1471f85b5facf8794924c794a8ac955d23c7716b876b18996b51c0da0", + "actualSha256": "db0aa6a1471f85b5facf8794924c794a8ac955d23c7716b876b18996b51c0da0", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1229-001/manifest.json", + "expectedSha256": "e363bc2cf7b375e9256d42554f4ab24a595762d2fafd4c793a25dd09d4c9ce31", + "actualSha256": "3d3ce9f32b5cbb6e6209f6694ce7535e3c89ccb209d500da51735cd1b24736ce", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1229-001/geometry-node-reader-production.json", + "expectedSha256": "895c0c4a254dcb4f98c3627496443c0a71b25964107bf4f6828afa19fe9d5708", + "actualSha256": "895c0c4a254dcb4f98c3627496443c0a71b25964107bf4f6828afa19fe9d5708", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1230-001/manifest.json", + "expectedSha256": "5cd12e8abd82a1d711f6cad1654e417bf7b571ef32f72fb15108e76d78b322a4", + "actualSha256": "219f18a6a297025cbe7055026c101427e92b4fac8dfd48d4c2e89a65040aa5c5", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1230-001/geometry-node-reader-production.json", + "expectedSha256": "82800190440cb6e215c561b065612faa0c611b58f1d6e9d35e27b2d999bc278b", + "actualSha256": "82800190440cb6e215c561b065612faa0c611b58f1d6e9d35e27b2d999bc278b", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1231-001/manifest.json", + "expectedSha256": "c1286d36fa7aa8cae00d79cf9a6034f81ac0a05cf2c3fa24d66b652fc2fc4e95", + "actualSha256": "1ec4172972526b0fbbbfd6674bbc664cf6d1d9dea9dc4af26143393dc18b7b10", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1231-001/geometry-node-reader-production.json", + "expectedSha256": "d3bb6e8dab77dccbd79f40014b1cd1e13c85be3d0e8cbc459d5a779e19a9b710", + "actualSha256": "d3bb6e8dab77dccbd79f40014b1cd1e13c85be3d0e8cbc459d5a779e19a9b710", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1232-001/manifest.json", + "expectedSha256": "6576b3fd5935696cd7e2b7c44f10d1159fadb5dc419faa513d63b7d8735ec64f", + "actualSha256": "f6d1ed493a7c82b049ded160ec7c7960144135153c88b65b380156de7f0ef681", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1232-001/geometry-node-reader-production.json", + "expectedSha256": "0773c7e460f6fa2604755bfa6d60a59236195f72fba3626d5dff8ae49bf85074", + "actualSha256": "0773c7e460f6fa2604755bfa6d60a59236195f72fba3626d5dff8ae49bf85074", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1233-001/manifest.json", + "expectedSha256": "ef1f90bb6be52213a81e1682f8ba2cc6a5ecf7ef5d4f88d16ad8c4f892aee36e", + "actualSha256": "ab9d50bb0688f252a2ee7ddeeab7673953d01a52dc310b31307e6bbdf0ca415c", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1233-001/geometry-node-reader-production.json", + "expectedSha256": "ff259d872c2dc1577ac3a5bbc8c2a401d7b07e81fcd8c5543b27328656d512f4", + "actualSha256": "ff259d872c2dc1577ac3a5bbc8c2a401d7b07e81fcd8c5543b27328656d512f4", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1234-001/manifest.json", + "expectedSha256": "220586b283f11d644486feea99841b3a67c1f58340bb67b3e7f51e4d0e11e0ad", + "actualSha256": "aa0846ee087d20d95b650371e11628a2a4c655e8e94a75a7349af308554d4749", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1234-001/geometry-node-reader-production.json", + "expectedSha256": "5fcab624d1cd980d7663eeaa826490c40fe7154c368fd558e33ca202945bc40e", + "actualSha256": "5fcab624d1cd980d7663eeaa826490c40fe7154c368fd558e33ca202945bc40e", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1235-001/manifest.json", + "expectedSha256": "219f860f3894d6a21ab9cdbe28774f9090fbc56cc246092209e94452f658d7b5", + "actualSha256": "4491cd009361b86be4eee967963ce6c08cdfd76f818d6c839ebfd72419999036", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1235-001/geometry-node-reader-production.json", + "expectedSha256": "33f4fe68578282f23d1460169faf48aa7cb87ab6fb1e7f68514f93642399d1f1", + "actualSha256": "33f4fe68578282f23d1460169faf48aa7cb87ab6fb1e7f68514f93642399d1f1", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1236-001/manifest.json", + "expectedSha256": "b92199b609ab263db5007945f64d7ef766b987aaa113b0af1cdbd8fa452c2a13", + "actualSha256": "6c0822513362de2cfe9047e5d01b6e38a2b0f4bfd2e140a76edab74840404b2e", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1236-001/geometry-node-reader-production.json", + "expectedSha256": "929b2c8c3dda00947ac021df85ddbbbb47aadceaf92f45010269d9981b332c7a", + "actualSha256": "929b2c8c3dda00947ac021df85ddbbbb47aadceaf92f45010269d9981b332c7a", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1237-001/manifest.json", + "expectedSha256": "42fc18da48ec5cbc7e79726bb285816dd76b1a71ca564de068a3bbfc00a28963", + "actualSha256": "564e964c08923eafcdc777a044d3d6f6bf77db3170af3dc5807eead172ba1440", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1237-001/geometry-node-reader-production.json", + "expectedSha256": "f8dffc9bee148a6b8db659c5e3ca1a85ac55cbda14c273d0369a1d562c593546", + "actualSha256": "f8dffc9bee148a6b8db659c5e3ca1a85ac55cbda14c273d0369a1d562c593546", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1238-001/manifest.json", + "expectedSha256": "b4fc4704eda144506a0b7bd84ed72805427f4115dde92190f8304f6e34779540", + "actualSha256": "cdd9117cb2a27fbde1aea6c084520092e9faadb309b5912f12c40ba200ea3e16", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1238-001/geometry-node-reader-production.json", + "expectedSha256": "6eddf8708ce5018f502964c3788341ffc19392882a85f641e89c3f3dd777668f", + "actualSha256": "6eddf8708ce5018f502964c3788341ffc19392882a85f641e89c3f3dd777668f", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P13-002/geometry-nodes-production.json", + "expectedSha256": "162456733559afde374edb97b7688145c74480a990b4f47d84842df44776a7f3", + "actualSha256": "162456733559afde374edb97b7688145c74480a990b4f47d84842df44776a7f3", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1239-001/manifest.json", + "expectedSha256": "c334a75cbb04bde8fe6bb795a2ed4743172d2b461b1d4cdc1d4db19e5796bace", + "actualSha256": "fc13c1bb110139627cf0528669cf9d630f953d576b159ba7bf0df23bd7a36ba0", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1239-001/geometry-node-reader-production.json", + "expectedSha256": "89b046d641d43ec39df8a208576acf472e78bb682788dc2929cb04ff176a4b80", + "actualSha256": "89b046d641d43ec39df8a208576acf472e78bb682788dc2929cb04ff176a4b80", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1240-001/manifest.json", + "expectedSha256": "2838533fab616e7244ba7c296d4acd0807850f7b4e504e6a79044f2afdbb1864", + "actualSha256": "98ece35b18068745b95f4ac5c4c696e76023ed97f29bba8964d5157720d76387", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1240-001/geometry-node-reader-production.json", + "expectedSha256": "09e838ff363ab9d722b8bc8f4c0f168b35e6550b0c0af1469b4c66ee8cacce83", + "actualSha256": "09e838ff363ab9d722b8bc8f4c0f168b35e6550b0c0af1469b4c66ee8cacce83", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1241-001/manifest.json", + "expectedSha256": "7d37710c6d5319a10a70ef97102cbbb819bd3507fca6fbbf9fbd8e3040e92456", + "actualSha256": "2b4145eba5a5da6df04ce514b87c1b009671f0e053d020ec7e199d02a946ee6c", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1241-001/geometry-node-reader-production.json", + "expectedSha256": "898260aaf8d98d7b4c62cfeae9f7247f71040ad73230e72b571a6154656d0a83", + "actualSha256": "898260aaf8d98d7b4c62cfeae9f7247f71040ad73230e72b571a6154656d0a83", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1242-001/manifest.json", + "expectedSha256": "7e4e9fc9c0e3fb0bb7e677b1dbb265888cb6c848d0e876cb94db54b7ef46595f", + "actualSha256": "1276259d615c62a816d966234603f31f281eb04b98bdfa85e5902c58f2d2960f", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1242-001/geometry-node-reader-production.json", + "expectedSha256": "e7309aea1ab150faf9ee795c7bf2ce104824ce04e264ffed47240b703c262919", + "actualSha256": "e7309aea1ab150faf9ee795c7bf2ce104824ce04e264ffed47240b703c262919", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1243-001/manifest.json", + "expectedSha256": "84a1e941e68d736bce24335908b737ef44f55ee7c76c737f73d227be3a30cca1", + "actualSha256": "d6672f5eb3ceeff0fd34bd79d8f3255b450a0873b3a4e56399514c4b78f792c6", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1243-001/geometry-node-reader-production.json", + "expectedSha256": "4026427b32ef100cd2622410188aab9f1dfb8e3a7dc9eae7aa7dd6f70d2b6879", + "actualSha256": "4026427b32ef100cd2622410188aab9f1dfb8e3a7dc9eae7aa7dd6f70d2b6879", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1244-001/manifest.json", + "expectedSha256": "e700543233ac26accb6062a52e4dc521daff7a3c4c1c3257d5ffd09dec4ad272", + "actualSha256": "b63c3ee33dae0f93b9a9749f949d1208dc9a474a84d95a776fe86c3025b73a2d", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1244-001/geometry-node-reader-production.json", + "expectedSha256": "b1bfad26fa73e574e242d91916910b18ff510eeb50b1116f9c602be218364768", + "actualSha256": "b1bfad26fa73e574e242d91916910b18ff510eeb50b1116f9c602be218364768", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1245-001/manifest.json", + "expectedSha256": "b7e40bba2b8925197304113fc8d083796bcfa1b4a42fe122a2ebfe8bd93179c0", + "actualSha256": "005bf4bb9a7c2d59727b7f5a8a18629c958b7d10a87f8b7a8dccccb0eb12160b", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1245-001/geometry-node-reader-production.json", + "expectedSha256": "645578200ec2c0379533bab530216191e281f178484c81f97125a34c3d6be74a", + "actualSha256": "645578200ec2c0379533bab530216191e281f178484c81f97125a34c3d6be74a", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1265-001/manifest.json", + "expectedSha256": "a3ff8ac597f44c81b62a6f21496f8382527e31f2b63be9f6fb3580797ef5a8d0", + "actualSha256": "d13a379867f728aad533dcf652b6094e6ef7b546ba9475e454b319175bed5ecb", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1265-001/geometry-node-reader-production.json", + "expectedSha256": "d61a0314f60e08cbe299183742330cda25a87e66408b4291edd1dd6cbc384123", + "actualSha256": "d61a0314f60e08cbe299183742330cda25a87e66408b4291edd1dd6cbc384123", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1266-001/manifest.json", + "expectedSha256": "e07260a278e863d0434a17f8c07ebb9c2d136f925c7de0282f9280bb79a0a6ea", + "actualSha256": "1459a5d5a0ee90d922b1c8f10d0eadb3c3f102420b8d238a3a8e7e84d908c120", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1266-001/geometry-node-reader-production.json", + "expectedSha256": "36ee363bd0d717384b0c16492b31535a0e6a3fabd3499d48549f910df5a76df5", + "actualSha256": "36ee363bd0d717384b0c16492b31535a0e6a3fabd3499d48549f910df5a76df5", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1246-001/manifest.json", + "expectedSha256": "83bf271cb9883e6f63d8188d4d838c294ee7bb301d255a1c51126cce2eef8aa9", + "actualSha256": "de5c28e76a1fd2a4202c336d3e4cbda9a9dc470f8cf4020ce24b589231abe5b0", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1246-001/shader-main-reader-production.json", + "expectedSha256": "e62b583b762550fd085e62097345a8631978ac7304b60d261b83d3edb3a650c1", + "actualSha256": "e62b583b762550fd085e62097345a8631978ac7304b60d261b83d3edb3a650c1", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1247-001/manifest.json", + "expectedSha256": "577926ff032c3ffdeb293680f3f9aead2ab79293f48c887afa4c5625e0295952", + "actualSha256": "44bfc3582aa3e6b858c4a7b30891d6c2cf22197092c29a4255b9234925a8babc", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1247-001/shader-main-reader-production.json", + "expectedSha256": "e5584464afabe883128a5e0d4f33329c168f120f660e5b4e43757abecd84f37f", + "actualSha256": "e5584464afabe883128a5e0d4f33329c168f120f660e5b4e43757abecd84f37f", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1248-001/manifest.json", + "expectedSha256": "ab547a161baab148d36fe481129bf4b6d28f73272b704bd3b353c7e463bc813e", + "actualSha256": "6c0a4b811cb4dde30f164375832e890d6c25b3e62cc6960d3dc5de5786e9b34c", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1248-001/shader-main-reader-production.json", + "expectedSha256": "2f45e5d5d0debb2a04c5ca1396c826ee42e7228cb58a8424e9f5bcdb7c0ce8cc", + "actualSha256": "2f45e5d5d0debb2a04c5ca1396c826ee42e7228cb58a8424e9f5bcdb7c0ce8cc", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1113-000/manifest.json", + "expectedSha256": "64725542af654b00e6c328a9725b3ebfea299e25e5a759aabccca2632fcd7740", + "actualSha256": "64725542af654b00e6c328a9725b3ebfea299e25e5a759aabccca2632fcd7740", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1113-000/shader-main-reader-production.json", + "expectedSha256": "4ebf59021a7b4c5993f13b9f0d5c300726dc0f080334a2ed0f5fe4af204dfdec", + "actualSha256": "8800088e351f3f8a3d780fdc4edc4e39e8304c67383edcea894bb9d6f6b970e4", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1249-001/manifest.json", + "expectedSha256": "d0e8ecfd9563069952dba245ff1787a13825e1118ad225704872588c09ed5a1d", + "actualSha256": "4070b90b00cd840041c641168df068255ec34a953a62ac2e03a686518845fbd6", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1249-001/shader-main-reader-production.json", + "expectedSha256": "2904f2a1bef8d92b25ce30f50e397db65fd832e7120c174758152239bc98efdf", + "actualSha256": "2904f2a1bef8d92b25ce30f50e397db65fd832e7120c174758152239bc98efdf", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1250-001/manifest.json", + "expectedSha256": "c521d78ffbd40fa900069bd11287c5e7196e0fa616a0fcd4942c7ad228251b36", + "actualSha256": "f4c56feb0cede4c7a6fd321b822a51f7b8528771582aca2516a07b57b44a9a35", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1250-001/shader-main-reader-production.json", + "expectedSha256": "fb780a3855f5dc1c75e87144e485609c98678a1c8a89852f376bd7ded8da4c11", + "actualSha256": "fb780a3855f5dc1c75e87144e485609c98678a1c8a89852f376bd7ded8da4c11", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1251-001/manifest.json", + "expectedSha256": "7bc3dc5281e08dda7a500cf9ed7ddc6f0a0b394d9289809ea27f7a925571f839", + "actualSha256": "d8500dd587e3da10c1a2b3b11346016244a1d9913c7c76e8e52f981f177625ec", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1251-001/shader-main-reader-production.json", + "expectedSha256": "88500a8eb450e6fa70217fbb3fc2410f4e6f01fd54568dfb491abb87cf71414f", + "actualSha256": "88500a8eb450e6fa70217fbb3fc2410f4e6f01fd54568dfb491abb87cf71414f", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1252-001/manifest.json", + "expectedSha256": "16368bb287a6b73685ee549b158b1b5f09d75c56882050aaddaf3ce63d0439f6", + "actualSha256": "90ac2c0738efbf391aab78c67742c540b730d0c4677b78f6262f68499743bc8e", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1252-001/shader-main-reader-production.json", + "expectedSha256": "d95951fc14f0f2d5acf0d59d10c295aa0b22ac0cdbed41184affbf0aca8ddc93", + "actualSha256": "d95951fc14f0f2d5acf0d59d10c295aa0b22ac0cdbed41184affbf0aca8ddc93", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1253-001/manifest.json", + "expectedSha256": "d72a05fc5821492110b72b8aacad8cc2daec0314df8c154e9796dec1ffe2bc0a", + "actualSha256": "9cc8ca55abac1018a7ba73246c04dfff456b67bc9dc9594847b459d023d16c51", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1253-001/shader-main-reader-production.json", + "expectedSha256": "ec5cee7a9e0b8a6a11b8bde169066a5c7ca11859918c9df2a1b80666d5014ae7", + "actualSha256": "ec5cee7a9e0b8a6a11b8bde169066a5c7ca11859918c9df2a1b80666d5014ae7", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1113-000/shader-main-command-production.json", + "expectedSha256": "a91ece1ce53fd6a2e2be073193c6d364c9323e178a1d62502a3ea97c9e2022b2", + "actualSha256": "a91ece1ce53fd6a2e2be073193c6d364c9323e178a1d62502a3ea97c9e2022b2", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1254-001/manifest.json", + "expectedSha256": "7210676d5a83b9444c2e258669096499b2e1495752b2658ff5c8d448062cc818", + "actualSha256": "334723a84a7330b87ee068102cdc772fea83c4c7f01a706eb495043472bb4179", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1254-001/shader-main-reader-production.json", + "expectedSha256": "77d6f1a8212a0d2ced6a0919a2a78dcab1b3c0346a3833c8078e8a834c3dba21", + "actualSha256": "77d6f1a8212a0d2ced6a0919a2a78dcab1b3c0346a3833c8078e8a834c3dba21", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1255-001/manifest.json", + "expectedSha256": "34dc0f7fc218c5b61eac5dd379d3f78b123b3d1e00b6a80edf61ff710d86ccec", + "actualSha256": "ada91fe793100fbab7525abf495f072e190563ce6aed27ced6492a77c0087ce7", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1255-001/shader-main-reader-production.json", + "expectedSha256": "14fe04d1a5e1a0f2a7a4627d7068cc7a84e92849c3636127f5754edae1e5141c", + "actualSha256": "14fe04d1a5e1a0f2a7a4627d7068cc7a84e92849c3636127f5754edae1e5141c", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1256-001/manifest.json", + "expectedSha256": "e763c94cb9be66ef613f666bd149cd26147c24aae05cee6460cf85a12d66cbfe", + "actualSha256": "f062c2fb21c18c19e3416318ab416ecd066f01c78ee034ce8e6ed4dd44f80bae", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1256-001/shader-main-reader-production.json", + "expectedSha256": "1efcb4d80948435a13b948f0ce126230e483ec2dc78b826f8ac45624586ece55", + "actualSha256": "1efcb4d80948435a13b948f0ce126230e483ec2dc78b826f8ac45624586ece55", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1257-001/manifest.json", + "expectedSha256": "50f1da9b55f5b8fa190069b8f201b2abe7f7a3f2483e3987484f206bd83481ab", + "actualSha256": "c6d62a4f50d22dd43472b74b7c9b235795684092cb2e7e644347dcce62d79268", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1257-001/shader-main-reader-production.json", + "expectedSha256": "21a0de355a5424db63019a48d13ac74c486befd5ae790f48743c132e2a6d1525", + "actualSha256": "21a0de355a5424db63019a48d13ac74c486befd5ae790f48743c132e2a6d1525", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1258-001/manifest.json", + "expectedSha256": "7079857c1ab332d1f030c9653ac87c31a30f8e9887d6de78f5bec73c721a57b3", + "actualSha256": "e3b36f370607e44cdded09be00d490181049a2315ebf257cc84002a815875cae", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1258-001/shader-main-reader-production.json", + "expectedSha256": "e8159ac9c6f641dd6294da5db80f33c9a304b3644b637da06dc8cc4a033611f3", + "actualSha256": "e8159ac9c6f641dd6294da5db80f33c9a304b3644b637da06dc8cc4a033611f3", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1259-001/manifest.json", + "expectedSha256": "c67490820798b0f8ef3cd087b95067e36fda21f5116847af89a9dd6360027757", + "actualSha256": "9dace4aed569eb278c692232d6a6778ab3226870974254ecf8c93983e5e307c6", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1259-001/shader-main-reader-production.json", + "expectedSha256": "1f953028ed879484caa02c342d5711172956c3f0825fe9b5b57d98874499f192", + "actualSha256": "1f953028ed879484caa02c342d5711172956c3f0825fe9b5b57d98874499f192", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1260-001/manifest.json", + "expectedSha256": "b91d842e5d7c4e9d21a4a12aab16ed7a4a0a7bb200550e8e6e74d252239de14f", + "actualSha256": "213714e1cfc39af9c0db067eacda10c29ae1d595a5d3f88fd34529390861d4dc", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1260-001/shader-main-reader-production.json", + "expectedSha256": "08b7f29f04f645f84e587d31b7ce38d4e33c7e38a29509acca9e9c59d2f9519b", + "actualSha256": "08b7f29f04f645f84e587d31b7ce38d4e33c7e38a29509acca9e9c59d2f9519b", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1261-001/manifest.json", + "expectedSha256": "58a1c7aa85aede9957da20986e6f0cc5baa328fc91dab4d8801d662e40b8de4d", + "actualSha256": "7940fd83656b37c887c8d5705cfc68277be559e67ab2c80358fe522f71737820", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1261-001/shader-main-reader-production.json", + "expectedSha256": "378fc00769da1af7a6f0403306beb8109ce8b0485ca40dc076fbc3a5185895c6", + "actualSha256": "378fc00769da1af7a6f0403306beb8109ce8b0485ca40dc076fbc3a5185895c6", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1262-001/manifest.json", + "expectedSha256": "f23dbb3f35c6d131e95c9cebc88c580919b4c0fdb6e99ade98c4a862ed624872", + "actualSha256": "879a6bf80e41337148f856e98c11c07e70c11c536750a5d0e7e8ca31e1c09fc6", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1262-001/shader-main-reader-production.json", + "expectedSha256": "14efe56012caed45791e265e4918fc5bcab269ee2167b2d1adc3f32d13ba7af2", + "actualSha256": "14efe56012caed45791e265e4918fc5bcab269ee2167b2d1adc3f32d13ba7af2", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1263-001/manifest.json", + "expectedSha256": "648e24f6439c2617d0a3b74c77139d947df7c8215e421fc43ef7afe3a1f06cb3", + "actualSha256": "7075c2d3c875239162cf30549aac131b48e6e6965f395dd1ece854df3bc623ac", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1263-001/shader-main-reader-production.json", + "expectedSha256": "134debd73efef7d377f10ebfe06aa6ba1c0f1221e9bff04e627c7f497a679ff6", + "actualSha256": "134debd73efef7d377f10ebfe06aa6ba1c0f1221e9bff04e627c7f497a679ff6", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1264-001/manifest.json", + "expectedSha256": "01a56b19a599631b4348512a4d5087866148af2aab56dd3b372ea18907c3a0f5", + "actualSha256": "082df5e4e46f441b6bb06dcb08c8421966fd3ccb83a240b326d419b71aefa8cb", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1264-001/shader-main-reader-production.json", + "expectedSha256": "b103745e665e37d4d34b61a468e6d5e20c441bfeab9fbf2916b5cf599e220b71", + "actualSha256": "b103745e665e37d4d34b61a468e6d5e20c441bfeab9fbf2916b5cf599e220b71", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1267-001/manifest.json", + "expectedSha256": "9d1ac6caf5ecb879e7d7b2c6aec42c5c2c512b5d2ed5da6eaa35460659c52203", + "actualSha256": "b437f8314510e1078c0d14b198d28e33ac906cd02c6f41ef157034a9a8d03562", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1267-001/fcurve-sample-production.json", + "expectedSha256": "32880daf761b28564612516f582a9d7c5b5bd793af93e25a0fcbd9bf5809f26d", + "actualSha256": "32880daf761b28564612516f582a9d7c5b5bd793af93e25a0fcbd9bf5809f26d", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1277-001/manifest.json", + "expectedSha256": "51d8b0e5f47a7692a5f63382bd55f89b0d514a114aff3aae95d2307c9570213b", + "actualSha256": "9ddba3f91e4fcb007bd71871ac4402cca9c445b9e8225d8c83874f003912b18a", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1277-001/mesh-topology-production.json", + "expectedSha256": "e36b04db94b202ec14a8d9c307bef8bab10dcb24a9ec5dd23b7ce2d308e8afc9", + "actualSha256": "e36b04db94b202ec14a8d9c307bef8bab10dcb24a9ec5dd23b7ce2d308e8afc9", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1288-001/manifest.json", + "expectedSha256": "aceec005f079986e3a70835600d3ef149c10a1c0c81cf634f2c4466248cf2a30", + "actualSha256": "7611da7b7a7f33a3698e2a985e178eb84e7011350e34a9ed5b25434a8557a005", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1288-001/modifier-parameter-production.json", + "expectedSha256": "89e5f48e5a0f0b39aeed479505cdafe29407458971892804a183dd57f66357d8", + "actualSha256": "89e5f48e5a0f0b39aeed479505cdafe29407458971892804a183dd57f66357d8", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1281-001/manifest.json", + "expectedSha256": "7707ff3261e8af46473993aa88cf6b2852235f140660a592c89adffd27ee5572", + "actualSha256": "342cef57c7646b7c09899ae74f817202d63d0c7ecdf16d459bb2baef4319842f", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1281-001/mesh-topology-production.json", + "expectedSha256": "0b6c8b5464af68519f3bd40b9418f6868414fe9ff9e43a77092f969fa9fc4052", + "actualSha256": "0b6c8b5464af68519f3bd40b9418f6868414fe9ff9e43a77092f969fa9fc4052", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1280-001/manifest.json", + "expectedSha256": "f0ce8e49f09f36f526a7693f59eff67eaf760814deba4a3bd48034752e24f185", + "actualSha256": "ae21f7f703be5da38e0b6c334e5ac3ca692aa391cce89791295f178a77d0bdb3", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1280-001/mesh-topology-production.json", + "expectedSha256": "6f00c0674955d90c1a45eb003ccfa147432e7de44070851f4a4e52dbd08e92de", + "actualSha256": "6f00c0674955d90c1a45eb003ccfa147432e7de44070851f4a4e52dbd08e92de", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1278-001/manifest.json", + "expectedSha256": "721395c8dbea283b827f8635a85a75f7a035210b88cf2a7559ac3b1521d74de8", + "actualSha256": "418b135f5a270fc687260eb7fb9dec2b4f616e8f5e5e9b655ae474ea3f80d66f", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1278-001/mesh-topology-production.json", + "expectedSha256": "ffb7c3b56635f24599a66fb3ff7382436b7ad0d6bba347b06dd2e16b32823ea8", + "actualSha256": "ffb7c3b56635f24599a66fb3ff7382436b7ad0d6bba347b06dd2e16b32823ea8", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1279-001/manifest.json", + "expectedSha256": "5e78c7c9adb4022bcbbfa992039e346ef2353d357b66e6b9806db4f7d70a2c45", + "actualSha256": "84c562c6c81dee2e86e9240a3bd28242f7f80a57388dcbe42dfd7a080c67a2cb", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1279-001/mesh-topology-production.json", + "expectedSha256": "7efa8650037826fe4e69f5f28fe8173d927c8eda3e5e69ca9e51edb462a8436f", + "actualSha256": "7efa8650037826fe4e69f5f28fe8173d927c8eda3e5e69ca9e51edb462a8436f", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1282-001/manifest.json", + "expectedSha256": "ba454f1a64ee61fe001423bc58ce794b139640433fff619a64017570c6ee18f0", + "actualSha256": "6c4fe91771ad1f72704694884f1c4c3c24b0d17b26d849d6e2d5073ec02befba", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1282-001/mesh-topology-production.json", + "expectedSha256": "b8f82dfa6ff6aa46a02100901ac9871958cf367ee29dd7a8317ad7594860a53b", + "actualSha256": "b8f82dfa6ff6aa46a02100901ac9871958cf367ee29dd7a8317ad7594860a53b", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1273-001/manifest.json", + "expectedSha256": "02eee329cc283f118a9cf0021bc4fd2bee98bf80c1a7bfb1f8a351acb55aee4b", + "actualSha256": "6b44cb2febc1ce5e411f4c92e9a95a836f75f40b86365cba1c36bc1150f4a452", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1273-001/primitive-cube-production.json", + "expectedSha256": "a3b50302911fc5c36d4fb04b756bfb3d5510e89e17e1be8dd7f3df8991b67c34", + "actualSha256": "a3b50302911fc5c36d4fb04b756bfb3d5510e89e17e1be8dd7f3df8991b67c34", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1271-001/manifest.json", + "expectedSha256": "d3b08ef39557da596055acf18155d0eeef62af9126bc0e799378884dbe93d035", + "actualSha256": "ecb3f173dc1820767fee44681eae4a4199e42bdd91f2ad69ee656b90ed433484", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1271-001/collection-create-production.json", + "expectedSha256": "31245f85812b2a3e78cb110f48870d7d7298d9da238bb7f0be0c2e81e0d940fb", + "actualSha256": "31245f85812b2a3e78cb110f48870d7d7298d9da238bb7f0be0c2e81e0d940fb", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1269-001/manifest.json", + "expectedSha256": "4256b973f177397ccf656116ba5532d61551978b59592ac98ebc5df0a5bf170f", + "actualSha256": "c013e1d899abc03e0b08ae2663984075e74f8ffbc8014719d2a69a1e2f7fb22f", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1269-001/object-delete-production.json", + "expectedSha256": "d387c0dc88ae25fa0d2fceef1b46767c736e5b581375973a158416cde080162f", + "actualSha256": "d387c0dc88ae25fa0d2fceef1b46767c736e5b581375973a158416cde080162f", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1268-001/manifest.json", + "expectedSha256": "588f6fc4311f07c9f668e1d690c4f3f5259ffd8c8415714fe38616fdfe5283f2", + "actualSha256": "b67a67f913fcedbd10ecffdb49a05d033443753ede7905db9d1b41b0b5ff36f0", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1268-001/object-duplicate-production.json", + "expectedSha256": "a0961609a4d849416f30e3e72e9717d03bd14f1d0ea09372b992a904bb487138", + "actualSha256": "a0961609a4d849416f30e3e72e9717d03bd14f1d0ea09372b992a904bb487138", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1275-001/manifest.json", + "expectedSha256": "956fdeac2855d73ba0c0f5ec8c82d123a5b701732daf9baf7be1486333d39238", + "actualSha256": "8a8a7c5496c06f365e6786a3254b37a619895f80cf462350e67635f836f3f8f8", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1275-001/object-visibility-clear-production.json", + "expectedSha256": "5921c708a0498a5732c1c51efa333a5afffdbac5d557fbc061e78116a22d7f3c", + "actualSha256": "5921c708a0498a5732c1c51efa333a5afffdbac5d557fbc061e78116a22d7f3c", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1270-001/manifest.json", + "expectedSha256": "ff692c59a6e45639dec6f44865ad3eb32ad13576e5283746330876bc0bbc3ff1", + "actualSha256": "dec9608282b466074cbfa1c2a5a449ace109eb1fad62c61757f3d561ed43fc3a", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1270-001/object-visibility-production.json", + "expectedSha256": "e4c60e51b81d8998f7000d9ebb4ad5a33c09775e9493ce97ab85b28a0dfeeb49", + "actualSha256": "e4c60e51b81d8998f7000d9ebb4ad5a33c09775e9493ce97ab85b28a0dfeeb49", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1286-001/manifest.json", + "expectedSha256": "bf9c736ab88ca8808b4e0daa267bc9f0caa4c849ffb2e2d1d89f25c1aae7eabd", + "actualSha256": "166c34889d95d5b01be94f45093ff94488fcbbc6a0acfd66393c3ffdc8dae6e1", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1286-001/mesh-object-operations-production.json", + "expectedSha256": "89ab3a06a6eda6dfe08dd045394ecb23548a6af4d14c6b596770d75cc57198a0", + "actualSha256": "89ab3a06a6eda6dfe08dd045394ecb23548a6af4d14c6b596770d75cc57198a0", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1283-001/manifest.json", + "expectedSha256": "d2791cdd17c7f1f6f0e6d1222e1a6d3a75d7449a0e0e0e0da303db7d31d34e02", + "actualSha256": "1b7f44e595d8e1a7c3e78550c245ac2e562b50411f1102c5e2953cd2f48dd72a", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1283-001/object-transform-clear-production.json", + "expectedSha256": "3ef5ce182e01ee724b3814d9528d9700ce06a0be969fbeeeeec953e25eca9cb8", + "actualSha256": "3ef5ce182e01ee724b3814d9528d9700ce06a0be969fbeeeeec953e25eca9cb8", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1287-001/manifest.json", + "expectedSha256": "1fc1ec6e805bb63c50badbd91f3efe280f18bd9dc2f137bc82627c344d7075a3", + "actualSha256": "e0ed3aeeda4a7a9a99e16559e71186f3bc9ed78389a7dc6917b8c421323d7668", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1287-001/material-slot-production.json", + "expectedSha256": "a8df3fc1e015981e27ff66f6e01bdf17a9bbd05e81b8c70932a828130d92a053", + "actualSha256": "a8df3fc1e015981e27ff66f6e01bdf17a9bbd05e81b8c70932a828130d92a053", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1290-001/manifest.json", + "expectedSha256": "1d0cd1f46211277971032d7e50d3103628dd32d928fcb4a45cb2396cd5447857", + "actualSha256": "dcd2f8a48e06851d62ee73a6669b61fe96167a9c39a2ef2596bc6766fd82bcd4", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1290-001/material-slot-assign-production.json", + "expectedSha256": "e20ad463078889c93cd786e38a4a7f6554c715a0e87748c57f5d94eb4bb26858", + "actualSha256": "e20ad463078889c93cd786e38a4a7f6554c715a0e87748c57f5d94eb4bb26858", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1289-001/manifest.json", + "expectedSha256": "e2fceca4397bbcfe1f5efec908cd353765ad94625b85723f6b644bb0eb69ecf4", + "actualSha256": "57fb277c983a235ed58838268a361cc604ecbf90b9943e284be76b076b9e8358", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1289-001/material-slot-production.json", + "expectedSha256": "df295a967e5a8a7111b94ae6069ed537a5e1d41dd45f2298ce550c1db3f6df82", + "actualSha256": "df295a967e5a8a7111b94ae6069ed537a5e1d41dd45f2298ce550c1db3f6df82", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1274-001/manifest.json", + "expectedSha256": "ebd0637b4bed5f690974ba2a162f698564e7b680706025759b7d307ab8add2bc", + "actualSha256": "80944f3360d223cb47efa8d0ba8bd5e678e69538d9dc27e03d021c2b13df4628", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1274-001/object-move-production.json", + "expectedSha256": "e11edcdc638bc800a8ba6a53c88c27dd390840df73aa97fbbb01e6562d89f66c", + "actualSha256": "e11edcdc638bc800a8ba6a53c88c27dd390840df73aa97fbbb01e6562d89f66c", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1272-001/manifest.json", + "expectedSha256": "414d0a5f90def841b5edd8e242cb5fa9f2ff598256d40c3ff49682f59c75a29b", + "actualSha256": "8a89f333130576a9577c4ccf754666bbaba1d2993d7ae0009aff1277c26d06ac", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1272-001/object-parent-production.json", + "expectedSha256": "22ebb288589a5cb36420ba2ad4e765d2101fa285fe8a481251c17dd26ca39f92", + "actualSha256": "22ebb288589a5cb36420ba2ad4e765d2101fa285fe8a481251c17dd26ca39f92", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1284-001/manifest.json", + "expectedSha256": "92fc0b45911d63c5ad990b8a9fdf0faed03cf880ad82d33c519449c258bdd4f6", + "actualSha256": "15f3905eb344d8e0d84be033760f44911528e45694031259f5bddde801175caa", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1284-001/object-transform-clear-production.json", + "expectedSha256": "d5c66b6d426eecceb996608a98d8f0e34fbcf54b8cbfccf8f00334eda0113436", + "actualSha256": "d5c66b6d426eecceb996608a98d8f0e34fbcf54b8cbfccf8f00334eda0113436", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1285-001/manifest.json", + "expectedSha256": "8383095f01abb4325ae6cca9f1df2023ed45f4ba14c36b966801ddecdfc765dc", + "actualSha256": "da2ebb39b3978fa83bd22931f45dc95f648607ffbe7672968c536d0fbee4f047", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1285-001/object-transform-clear-production.json", + "expectedSha256": "facbb87002df01825c04ccbfe7f0231ef7f020e941bfdf2e5f239bd561e4806c", + "actualSha256": "facbb87002df01825c04ccbfe7f0231ef7f020e941bfdf2e5f239bd561e4806c", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1276-001/manifest.json", + "expectedSha256": "4e5edb781d407b2f0fa31d08a411308800c858257060eef94fee524b99413865", + "actualSha256": "3318590fc2d34a9524a2fe77449088143374e2c7c2af3b2ae643582199777978", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1276-001/object-transform-apply-production.json", + "expectedSha256": "1f12b9185a53cbf80d92621c6979ad61df797fe6c88ed98f8674790d39f4f8c8", + "actualSha256": "1f12b9185a53cbf80d92621c6979ad61df797fe6c88ed98f8674790d39f4f8c8", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1291-001/manifest.json", + "expectedSha256": "5994027f5073f81f4a55ea3a3a9d60b279a24747738bd8708735f380373923fe", + "actualSha256": "27336871286dc6069f00ff594f03d7340bcde5be8e029f52c9499294865da103", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1291-001/uv-unwrap-production.json", + "expectedSha256": "2957a72665aa40dd30db4041e6fb49db62eb262cc9f374b9630cb7ce698bb2ab", + "actualSha256": "2957a72665aa40dd30db4041e6fb49db62eb262cc9f374b9630cb7ce698bb2ab", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1109-000/manifest.json", + "expectedSha256": "b5b322c500b52fbf8610777c4793b48ccfb1999543924e8a7e9b34e905d9e2d1", + "actualSha256": "b5b322c500b52fbf8610777c4793b48ccfb1999543924e8a7e9b34e905d9e2d1", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1109-000/io-format-operator-production.json", + "expectedSha256": "0920e17254d9822f38a8476e26c5469c2177b730afe7859d4986dffa0de0d8df", + "actualSha256": "0920e17254d9822f38a8476e26c5469c2177b730afe7859d4986dffa0de0d8df", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1129-001/manifest.json", + "expectedSha256": "105a7af457fa1e603aac604f21a3dab8685dd692a7f78ec2fc9fcfc3815a4af4", + "actualSha256": "105a7af457fa1e603aac604f21a3dab8685dd692a7f78ec2fc9fcfc3815a4af4", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1129-001/scene-settings-expanded-production.json", + "expectedSha256": "c8e22f394ec81f07f15c176878b1d6c18c9612fe57146b5856af2714b771f9ca", + "actualSha256": "e68cfe6cd360f5714ff4bc7882815ccc02ef4b90f8320fc3bceaa1950f3c97d3", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1112-000/manifest.json", + "expectedSha256": "325ff46c0ac2651650c6f83a6bb250deb1a1276c1749966e57243143708b36db", + "actualSha256": "325ff46c0ac2651650c6f83a6bb250deb1a1276c1749966e57243143708b36db", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1112-000/animation-action-production.json", + "expectedSha256": "0ac5b63e5210bdc68c71d9652b4430397654e9e0de8c7763a6bf1e88c183fdfc", + "actualSha256": "b1a66dfcf6ecbe9af3fddb4fd814aa207b39e771b8fff82c9790b5208f931551", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1140-001/manifest.json", + "expectedSha256": "967d1d78a4521c583b9f0d9bf68e9c7fda1a68191c5762e5e35c2627d4deb8c3", + "actualSha256": "967d1d78a4521c583b9f0d9bf68e9c7fda1a68191c5762e5e35c2627d4deb8c3", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1140-001/action-group-reader-production.json", + "expectedSha256": "74ac0cefbe8699d8371f9a5c9c69feb3c21622e430bceeb4440ff9e9924898ee", + "actualSha256": "571c2d7b52293f992ebd13d947e6ae137028c6dcd9c2cfa389fcab5b38e94e98", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1141-001/manifest.json", + "expectedSha256": "adba6098893f24eecbd6d6ddd57280745a23f1c3b4c9f46619398555f561aa1d", + "actualSha256": "adba6098893f24eecbd6d6ddd57280745a23f1c3b4c9f46619398555f561aa1d", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1141-001/action-pose-markers-production.json", + "expectedSha256": "4f2cc4712b8aa5e6d8be0e374bb84e871b69bb92cf557a4b805047b598e74235", + "actualSha256": "94b6b464e39d880bf7ece599807f23941f859f082a73ad8aaa098cb91475403d", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1144-001/manifest.json", + "expectedSha256": "b63a84f5f3d67c3e38013c68f81c676655408f0fd6f72fc91475c943254b0c09", + "actualSha256": "b63a84f5f3d67c3e38013c68f81c676655408f0fd6f72fc91475c943254b0c09", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1144-001/driver-reader-production.json", + "expectedSha256": "be2f7fb8620221d3d187ac3fae54a07e0c6f9d8feb727917b055d2a36fa757f6", + "actualSha256": "febaefca51c9489998b681693cdd1cc0a5358f4ecefba1f77cfaa330a7901f16", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1100-001/manifest.json", + "expectedSha256": "87bf6b132cc1ccdc3aa5d2bc0fa63787240692ade9cc98aa9be68a292cef5f92", + "actualSha256": "87bf6b132cc1ccdc3aa5d2bc0fa63787240692ade9cc98aa9be68a292cef5f92", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P15-002/lighting-fields-production.json", + "expectedSha256": "3c19c2586ee954432d23861e03813b71fc02cdb4959c400ea1e83999af0ce6ed", + "actualSha256": "3c19c2586ee954432d23861e03813b71fc02cdb4959c400ea1e83999af0ce6ed", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1106-000/manifest.json", + "expectedSha256": "7e0c0f6a64289c836846809f9d4fd20eb0fcb1dc681d534f3ca2b4f2bde586d2", + "actualSha256": "7e0c0f6a64289c836846809f9d4fd20eb0fcb1dc681d534f3ca2b4f2bde586d2", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P13-003/rig-pose-production.json", + "expectedSha256": "67fe9df8cff5730419f51ba196d24778be13720979c7f3c2fdf63ee8875bbd9a", + "actualSha256": "f79cf06e2b96fe6ef332d1714fdfebe39c3cb08a5f1dc8f406bc6db345634eef", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1100-003/manifest.json", + "expectedSha256": "7ef94e89e561ea6d7b3c55559396b3cd70be9ca9bc31733c05a1adaf1368a674", + "actualSha256": "7ef94e89e561ea6d7b3c55559396b3cd70be9ca9bc31733c05a1adaf1368a674", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1100-003/material-image-production.json", + "expectedSha256": "d2c45ebaf751daca9b7db69bd02a0b430547ed7995c89b26139fdac93def6c99", + "actualSha256": "b1209836c264d62f5afd0d11a9ffe8e629cac50dcf6779087adceadc61ad6282", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1101-000/manifest.json", + "expectedSha256": "a6ae78f9160a2fa16bf49cc96c1911dd015d822f50b1dde1631eb5805e66a302", + "actualSha256": "a6ae78f9160a2fa16bf49cc96c1911dd015d822f50b1dde1631eb5805e66a302", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1101-000/nonmesh-main-reader-production.json", + "expectedSha256": "20fe7d0bf040a3a7ce9e08f72e5989cf5254d9d2dfe2ec49123c5abe17ea38fb", + "actualSha256": "20fe7d0bf040a3a7ce9e08f72e5989cf5254d9d2dfe2ec49123c5abe17ea38fb", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1100-002/manifest.json", + "expectedSha256": "e06cb1087e7efade3efbd09de5ccedc90ecb4d5d809e71286b783be9bfd5e3d0", + "actualSha256": "e06cb1087e7efade3efbd09de5ccedc90ecb4d5d809e71286b783be9bfd5e3d0", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1100-002/mesh-main-reader-production.json", + "expectedSha256": "2da17d3789d6bb41c844ded1fd8a095d540a4cad505fe714ee99e6f08995cd10", + "actualSha256": "2da17d3789d6bb41c844ded1fd8a095d540a4cad505fe714ee99e6f08995cd10", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1132-001/manifest.json", + "expectedSha256": "6563854606c458b230b24650510b26360ad92e66e4152ccba0891c90209ecee1", + "actualSha256": "6563854606c458b230b24650510b26360ad92e66e4152ccba0891c90209ecee1", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1132-001/curve-handle-production.json", + "expectedSha256": "735c6defa17946ea38e80e3988f0f123b913d48fd3b9215d2bb401ead4c16a02", + "actualSha256": "0fb4dba15cebb1f9b606b55b2187d1eddb28561130a7737b3d555a096fc331ca", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1100-002/main-datablocks-reader-production.json", + "expectedSha256": "140bb665c492648ae089b3c088aef81edb242592fd21975c7c5b15eda3da84e4", + "actualSha256": "140bb665c492648ae089b3c088aef81edb242592fd21975c7c5b15eda3da84e4", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1159-001/manifest.json", + "expectedSha256": "7bb3eea5c12d8cb29cfcda7afbf5890265c6daa88dc133faf05b723ab6c9d5db", + "actualSha256": "7805c6aebb18f4766a0e176762385e592698ff39847a344e1c9f463db0f50c83", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1159-001/line-style-reader-production.json", + "expectedSha256": "ee652cdc845647206b3856d97c781f623ef7905ffe54c29b366f2a8c8ce30535", + "actualSha256": "ee652cdc845647206b3856d97c781f623ef7905ffe54c29b366f2a8c8ce30535", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1103-000/manifest.json", + "expectedSha256": "b593f1f9e78968d894d992771bf76a477e8cf983fe8880f47d053c8b2e9061de", + "actualSha256": "b593f1f9e78968d894d992771bf76a477e8cf983fe8880f47d053c8b2e9061de", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P20-002/collection-create-production.json", + "expectedSha256": "25e0731dce332d0802e15120627b5ccf378fa9ee6d5ab2f07f3f52c10f7d4ea3", + "actualSha256": "25e0731dce332d0802e15120627b5ccf378fa9ee6d5ab2f07f3f52c10f7d4ea3", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P24-002/object-move-production.json", + "expectedSha256": "afd8c884c8a8eb5638e032f9d186b14256378438d48d5f19a2ba8916089490d5", + "actualSha256": "afd8c884c8a8eb5638e032f9d186b14256378438d48d5f19a2ba8916089490d5", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1129-001/scene-color-management-reader-production.json", + "expectedSha256": "c3048a961cc4f52b971b223940ef5a58bdd70a43a00f84dc6e11ec70a443e854", + "actualSha256": "c3048a961cc4f52b971b223940ef5a58bdd70a43a00f84dc6e11ec70a443e854", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1101-000/curve-create-production.json", + "expectedSha256": "b336c2d236a7f2dd5711571f60103002139843f1174efbe1e6cb18518967de2b", + "actualSha256": "e4cdd0d5f13f1d3cd84fe21881176a21e1496fe45d5e5ba9f6ad239101dcd17c", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1133-001/manifest.json", + "expectedSha256": "fa280e6cc7b9a5b12c74e7533e63552aa576ab59735901bd6999e85877e4b68e", + "actualSha256": "fa280e6cc7b9a5b12c74e7533e63552aa576ab59735901bd6999e85877e4b68e", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1133-001/curve-splines-production.json", + "expectedSha256": "5ef561f5f0a48140121b1d577c376bcb0b2f4f97f568a64afbfb9825bbd991c6", + "actualSha256": "d4fb181ac0610c1931d71e0b28ee5b09e096c502b43e4badd1c48d4d1cc5bb60", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1155-001/manifest.json", + "expectedSha256": "4df78620513dd3dfb3a856ba29c96740b8b4074990e8ce1faaa5df90b7c61b27", + "actualSha256": "87c88f65b2ebf0585e37d0fd9806986456a5b664e003510d2aa6131e550cb1a0", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1155-001/modifier-reader-batch-production.json", + "expectedSha256": "48ef5b1a0041e8582a36299595ba7fd867b71614cf7b8a8b61d6ac9361635610", + "actualSha256": "48ef5b1a0041e8582a36299595ba7fd867b71614cf7b8a8b61d6ac9361635610", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1139-001/manifest.json", + "expectedSha256": "728c860121406d1c6b71369bdae77132d3dad37573e262bf730f27258a4de266", + "actualSha256": "728c860121406d1c6b71369bdae77132d3dad37573e262bf730f27258a4de266", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1139-001/texture-properties-production.json", + "expectedSha256": "677f3a9dafc5db037ea9414a5e4f12a8f5d30221a4623e7b889071362c7fd04a", + "actualSha256": "eec9787309b4f10f37e3db119ccae80305e4cae18bc23fd7eb37e5ca625cd769", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1143-001/manifest.json", + "expectedSha256": "296b20ab4b05fee1d1e5b4e908ebaa0c3a854ca59ec8f88d98c9e85b03e8c0da", + "actualSha256": "296b20ab4b05fee1d1e5b4e908ebaa0c3a854ca59ec8f88d98c9e85b03e8c0da", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1143-001/fcurve-modifier-production.json", + "expectedSha256": "485380421e0fd2bf0e31cfb567d56455e2182113f231e7012c25b1deb5439cf7", + "actualSha256": "9e0ad1dc801d0da4b68f0fb0e4982b11b57b1591990e75b1d3fe6cdd2a0d1ffc", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1142-001/manifest.json", + "expectedSha256": "da39cdefc86276354d6f6c7e9234d3537bfa252257cf40301bf7323b8b404106", + "actualSha256": "da39cdefc86276354d6f6c7e9234d3537bfa252257cf40301bf7323b8b404106", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1142-001/fcurve-sample-production.json", + "expectedSha256": "efd699ba1eb3d87b2526212c7ef621941ed656f2e40dc6a65e79951e3e309dce", + "actualSha256": "86e67fd95306f91b130bc22247cbbfa10ee872ecd9c43a5b611750809fdb48d5", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1161-001/manifest.json", + "expectedSha256": "ea752016414061582e07dfdaa58e1251910402ac1df1606ce31ff8086494c342", + "actualSha256": "d82eed5d828fe78c7f144cb4ddfadd1a6f4788f9ad990872e29a58ecbe01edd7", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1161-001/fcurve-modifier-production.json", + "expectedSha256": "2f0955ea63f11a1c28969d31e277a3007bd1625074b64bbf2284ef2c0264e77f", + "actualSha256": "2f0955ea63f11a1c28969d31e277a3007bd1625074b64bbf2284ef2c0264e77f", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1158-001/manifest.json", + "expectedSha256": "035735e025726f96fa718d01946c38f287a044353de4a90cce555a39bf76d36e", + "actualSha256": "519d51cd20282b5ca941ab33ae359e06ac33a034f216805275f1f58fb05a2556", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1158-001/line-style-reader-production.json", + "expectedSha256": "9e7535962e5f4abc80e28921a3501b73edae78efd0c743c553617ca7b91e3f0a", + "actualSha256": "393fba75329906584f21581df781d66e06a3bdfac7018bda2715585a2e600c0a", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1114-000/manifest.json", + "expectedSha256": "b53a7f147ee8714c2884c10201723b7cf90b72a3dabdf99626dff8ce77896773", + "actualSha256": "b53a7f147ee8714c2884c10201723b7cf90b72a3dabdf99626dff8ce77896773", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1114-000/grease-pencil-strokes-production.json", + "expectedSha256": "a538a1548ce5af17b7bc9bb3aeb8529a35c2a4c45943d4bdcd25f192dca0bbb1", + "actualSha256": "dd79fd9fc4db76e3f0c2ebcf4b45245c3b49abd281fbd70de1f8b9dcc46c0be4", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1114-000/grease-pencil-layer-frame-production.json", + "expectedSha256": "482a750f2100e2c3afd4742f19b0ebdef8986684befa663cfc1b12c26cc03dfc", + "actualSha256": "ffdcc7f486cca8f34e931958d73949c5bf665b22fa950044a0d4f7a522fdc896", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1100-003/material-face-slot-production.json", + "expectedSha256": "6f6a35a44495d3fe28978e54a07d10d5b07819bb0c063677a1461072d83660e1", + "actualSha256": "5d2891a0ed94332fef29de48c744fb7eba72517bf2e2e49b2c302101a714e4fa", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1160-001/manifest.json", + "expectedSha256": "d9e13a88bcb7ef67d9f26084ead19cd66da748e44b25942386be0d46b7618bcd", + "actualSha256": "f2c6216a3354043541a08d310e33aec15d3fc3e9fd1cc9ac958ec917e724ccf6", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1160-001/line-style-reader-production.json", + "expectedSha256": "8921b4d6d6620787dce701cea144c2dd150ceea635aac400bd0c7bdeb2e4f0cf", + "actualSha256": "8921b4d6d6620787dce701cea144c2dd150ceea635aac400bd0c7bdeb2e4f0cf", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1127-000/manifest.json", + "expectedSha256": "c3bae95931e03e884a413584e43d501da508a47225c3d4b1dd86b2347b41e00f", + "actualSha256": "c3bae95931e03e884a413584e43d501da508a47225c3d4b1dd86b2347b41e00f", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1127-000/tracking-mask-production.json", + "expectedSha256": "e07d348ab9f408318cf54dcdfec3746c0650cd32683b356712fcca3da574c987", + "actualSha256": "e07d348ab9f408318cf54dcdfec3746c0650cd32683b356712fcca3da574c987", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P12-003/material-animation-production.json", + "expectedSha256": "2766bd170db908ef53637677c485e57bd92bad8fb593f0a367a67ed0460578fa", + "actualSha256": "35851a9cca39bf8efedababcbcf459cc04ff6b33a5ce4fb0ed944664fcf36403", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P12-002/scene-object-production.json", + "expectedSha256": "d42649c1b8b382084e9838a754cd3231009762f24d1487230d96bdf0ea053ab6", + "actualSha256": "5579a68800320fa19fe40ea5a791a0f0f0390832e6c2d040c14458aab7ad29ed", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1137-001/manifest.json", + "expectedSha256": "65f8f5efc15a7bad864f9b158260ecc0e343a26610a9afacf7b91ba9a23c6458", + "actualSha256": "65f8f5efc15a7bad864f9b158260ecc0e343a26610a9afacf7b91ba9a23c6458", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1137-001/metaball-elements-production.json", + "expectedSha256": "2c22a9e814d47646cea451f99d66aa2106d25140a901d45fedbe5ef8ff6473c3", + "actualSha256": "ffa1acceb08b9a62683e665c43b2ccbd6bd893e9fb3d690cf39f608843e4e573", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1107-000/modifier-visibility-production.json", + "expectedSha256": "218ed7088d76f5ce6585f6ee99fb306a21f98292009477d3a929f25eb9608698", + "actualSha256": "d7a4b6531ac33d86489f293474152a32849f6a08a3e8085e7a74444dc66afe67", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1112-000/nla-stack-production.json", + "expectedSha256": "c15525a30b3a2ba0e6e486105d95abc0b149968106d51cd53f7414506bff7dfa", + "actualSha256": "4423cc6bea63b1d015f1c25ee127eda6f959cda4f7aa12630359d25747025f34", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1105-000/manifest.json", + "expectedSha256": "c58f5cf82dfa4b2712501d5ff818ada2e658e9c352836ef9fa4a7e95ab85e6f9", + "actualSha256": "c58f5cf82dfa4b2712501d5ff818ada2e658e9c352836ef9fa4a7e95ab85e6f9", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1105-000/audio-particle-production.json", + "expectedSha256": "2a231bf5e4f47d90e1896e5e80fc02574abadf8d3ca4982e5eff96c4b968b545", + "actualSha256": "2a231bf5e4f47d90e1896e5e80fc02574abadf8d3ca4982e5eff96c4b968b545", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P12-004/viewport-nonmesh-production.json", + "expectedSha256": "a3d8317c9e6d0611bf2ed20f452f242599df92b9bc82637c679e6880974e73c8", + "actualSha256": "465aa9eade1251b08d2c9e9a94eb8114ad2d0341da00466948f257afe9143ef7", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1100-001/light-subtypes-reader-production.json", + "expectedSha256": "bf6062033c1986a57559b09f37e9f5f2a8af1ec2b98d8bf9caa9f5db9396f6b5", + "actualSha256": "bf6062033c1986a57559b09f37e9f5f2a8af1ec2b98d8bf9caa9f5db9396f6b5", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1131-001/manifest.json", + "expectedSha256": "ceb854e75ec79f7ef38d05878aea40cca76fe0f0cd4bc67b539cdcdbdf59778e", + "actualSha256": "ceb854e75ec79f7ef38d05878aea40cca76fe0f0cd4bc67b539cdcdbdf59778e", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1131-001/scene-multiview-production.json", + "expectedSha256": "27ee1949937275ca41daa7101a7b74e1961701158e672a7f0bc17d014865584b", + "actualSha256": "101341b3c5d986435e8c5f12e75bf4551bdd1a19cceddf4e147b916e1cebffa7", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1157-001/manifest.json", + "expectedSha256": "f0e7874f61631672e957bf657d0d9eeb054aa08791cb0252e4dd8afb3e5f2ca6", + "actualSha256": "2258de93a1a0716b35691246f4f9f879fce07ce1c57586ea6b7499b5031ab99e", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1157-001/shape-key-reader-production.json", + "expectedSha256": "81dcc05b370a4ec640d28e33d0c6ae28714ab7ec1cf486df268507850b650eca", + "actualSha256": "81dcc05b370a4ec640d28e33d0c6ae28714ab7ec1cf486df268507850b650eca", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1134-001/manifest.json", + "expectedSha256": "8d476153c618028137274a9de0b397f721b9579f23e5ed03b4448537323567ab", + "actualSha256": "8d476153c618028137274a9de0b397f721b9579f23e5ed03b4448537323567ab", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1134-001/surface-topology-production.json", + "expectedSha256": "5723644f53feb5ebe97699b7328902eeea4ff4088901029a07514e4d2ab7c182", + "actualSha256": "dc4f569e3f6ff55d8d66e7839e1b4e54880b2b1be82fa1540b30d0f4ba2b2dd9", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1138-001/manifest.json", + "expectedSha256": "2a155d7af004ec81ded56522a0728124379949594cd03ef5859524835ff5ad02", + "actualSha256": "2a155d7af004ec81ded56522a0728124379949594cd03ef5859524835ff5ad02", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1138-001/text-source-production.json", + "expectedSha256": "f160f2d4f3037d3369d3587acb51eb99a655c9192d25c7b46d9cf93aee1d8abd", + "actualSha256": "a096dd8fc5ef1857f23650eed41b4e52c238fb19f5ae0aaa75a7e8395538d1fb", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1136-001/manifest.json", + "expectedSha256": "c2998ee4090cce43424836e494ac738f773c590c6f4222079477c3bded5de2a1", + "actualSha256": "c2998ee4090cce43424836e494ac738f773c590c6f4222079477c3bded5de2a1", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1136-001/font-advanced-production.json", + "expectedSha256": "e557d501331fda36eb2bc368d1200250faf37acc69d4e7cb70d1a780a080e301", + "actualSha256": "07f5c0e3292740a147d84f331b24f3eff57db9ab62c93c4218a2622e5465a351", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1135-001/manifest.json", + "expectedSha256": "9b31fe65666240c89daed6ff3438e8007d2d8197e84150f0080ee58a6586191f", + "actualSha256": "9b31fe65666240c89daed6ff3438e8007d2d8197e84150f0080ee58a6586191f", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1135-001/font-body-production.json", + "expectedSha256": "f81e0eba27285d736c6881645d8e0f5e8c6ac7e3fb00f5edd0d3d479be4509d9", + "actualSha256": "fb97650d56251075baeb3b077f9104fc0c00acfd55f4d1fc2e84658ff51bbe9e", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1120-000/manifest.json", + "expectedSha256": "8aec3ba274efb1e34c88deef1ae9fb551f9cecb9049cf01972f9665bc6d70e67", + "actualSha256": "8aec3ba274efb1e34c88deef1ae9fb551f9cecb9049cf01972f9665bc6d70e67", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1120-000/volume-properties-production.json", + "expectedSha256": "5cc5c114884ecd8c24764fcb7a0101da944824819dd03585bd44d804e06e562f", + "actualSha256": "f8893695cb39c990ff143c7598ed210f2d6d4e67ab3062dbeeb5fbb3d7f4edb8", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1100-003/material-slot-production.json", + "expectedSha256": "8abff376fdc277d78234cb7b2c1cfc0d5658f6483addfa4660bd89accaac1710", + "actualSha256": "882e25bbeb9c9e1aced5042fb2c72472a89c64f4d1f3de392e3fbecb6a25f428", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P23-002/object-transform-production.json", + "expectedSha256": "798b2f8da36670b31e6704c061f50ec7343cefe5b79499cb90be5a0f470e0ffd", + "actualSha256": "798b2f8da36670b31e6704c061f50ec7343cefe5b79499cb90be5a0f470e0ffd", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P18-002/object-create-production.json", + "expectedSha256": "e393ebc72f7aff62aaef8ad03f2fb2b8cc1fb26d19e72ca12348b919c1ff7f06", + "actualSha256": "767d592d67adcfa63a75ed96434a70de33dacd7d290703e0e8c06fc31749861d", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1101-000/nonmesh-delete-production.json", + "expectedSha256": "d8a8e8c57b5a72a9141d3aef6ad3389d4307ffb8e599d093b136feeb7222acea", + "actualSha256": "0dca8228dd22a7dd21f562c2f3d11f568ec6f181d42a3e7cf445b863f1db4dee", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P22-002/object-delete-production.json", + "expectedSha256": "82dc735ae2d8422219052ba963299cab56fd372e49150205a5eb3772411ff027", + "actualSha256": "82dc735ae2d8422219052ba963299cab56fd372e49150205a5eb3772411ff027", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P17-002/object-duplicate-production.json", + "expectedSha256": "b6a238f4a48e050c2e52299c936dc9136cf3dca74ded8f3af5628f5af84edcdb", + "actualSha256": "fc8314ec9612134875adeee92e197c3c03db7b272e54434b28405f9f6ea85c90", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1136-001/font-import-production.json", + "expectedSha256": "b2a36f20fcc122e52fec9f9efcb5c4489e3b54c66620d64a78619e2e363f76cd", + "actualSha256": "b2a36f20fcc122e52fec9f9efcb5c4489e3b54c66620d64a78619e2e363f76cd", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1103-000/mesh-object-operations-production.json", + "expectedSha256": "92a1c974fb6262dba6ed40a69adb13113320d504b90ad3a9aa030fc5d29bdec8", + "actualSha256": "aa3330b7d969d7fe8cdaeb9b5c2d210cd2fffbb707f4e87f665a69f2de8b3dcf", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P11-001/mesh-topology-production.json", + "expectedSha256": "fe2b6d610e999093bc54a055f54369be71ab86221a070047305346f25949568b", + "actualSha256": "04ec52f8ddbbb66b02032ff31529bd839fe9b69d64f425b0ebb6cc3babe0ffdd", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P21-002/object-rename-production.json", + "expectedSha256": "84398d062b165c8339307e04689229893ffcbe43806678b4db59325e0d883b7c", + "actualSha256": "84398d062b165c8339307e04689229893ffcbe43806678b4db59325e0d883b7c", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1121-000/manifest.json", + "expectedSha256": "f397cc25d4181ce2391c25b9ad563697c2a3d2d2a1be5cd8675e1255a51d37b5", + "actualSha256": "f397cc25d4181ce2391c25b9ad563697c2a3d2d2a1be5cd8675e1255a51d37b5", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1121-000/sculpt-stroke-production.json", + "expectedSha256": "92cc19a39cfeb13713056c8114d6d2b4c61cc8aaafabe6b45f77b8d6ecac4968", + "actualSha256": "9b23d74bc9592748bb2f61eb83e7addc9bc90afd27485e08b5572febebd92dfc", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1132-001/curve-handle-command-production.json", + "expectedSha256": "dbabcc13c498ec2299b00737ea7c96e2c2f3a76490bac6dca433307bc6b21ea7", + "actualSha256": "ae657f73f69372e9cd1d7d17b9ddda73bddeeb2e958e55a2bff41122f12de155", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1136-001/font-properties-production.json", + "expectedSha256": "644e420bd15a1305d9fac0768d43793df1d8f09b03f58e2eb93aaf8349dd094f", + "actualSha256": "edb39e8b4419158fbaaf62889950d8d34d838a9594076575d58b8549fc0575f1", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1112-000/nla-production.json", + "expectedSha256": "655b1ada4fa9d2b55db12094dd3f463621dd60de179efc089346a08319e14b43", + "actualSha256": "655b1ada4fa9d2b55db12094dd3f463621dd60de179efc089346a08319e14b43", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1101-001/manifest.json", + "expectedSha256": "11348720f1e3ba4b26cc6fc89f15fb6485caf7b5628b5402a272439ead81926c", + "actualSha256": "11348720f1e3ba4b26cc6fc89f15fb6485caf7b5628b5402a272439ead81926c", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P1103-000/object-origin-production.json", + "expectedSha256": "c9f53e0cf3545f0642f05ac888d425e02572c0ffa9841809eb90e717805b0be8", + "actualSha256": "9cc13e70e0fdf0420ad5e5435379393edfc2d3d23c7ca33106cba30d30125fe7", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P19-002/object-parent-production.json", + "expectedSha256": "4c0d5dbda9d2157b281ad35e1ab1fac6f65e7a4b0533ca597932f11b53a13f0a", + "actualSha256": "4f92e166ec2e4f1b2f908e5df1b1715a353af7b4cd0a42dc0fda87f643053c17", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P1129-001/scene-settings-production.json", + "expectedSha256": "972a39a3f5ee81127809318de2c3a7cc605931554d601dcdc821a047579de611", + "actualSha256": "8421d69531b6969af229dafafb685eefdc65042f64522f1b04dde8dbb91dbabd", + "status": "DRIFT" + }, + { + "path": "tests/golden/WBV2-P16-002/paint-attributes-production.json", + "expectedSha256": "cd38def8bfdb896c9c4e769c9032ffb25fb1ad1ad32e3730cd298631ed8c2e46", + "actualSha256": "cd38def8bfdb896c9c4e769c9032ffb25fb1ad1ad32e3730cd298631ed8c2e46", + "status": "MATCH" + }, + { + "path": "tests/golden/WBV2-P10-002/native-engine-production.json", + "expectedSha256": "948d6388544bc223bc30b8902495d64e608dc873791d30ef9d6281b70374968e", + "actualSha256": "f021237b75022227f173506de63537610c8c3cbbc3c3813f7f461913ab4e0189", + "status": "DRIFT" + } + ], + "units": [ + { + "unitId": "modifier-source:MOD_armature", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "modifier-source:MOD_array", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "modifier-source:MOD_bevel", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "modifier-source:MOD_boolean", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "modifier-source:MOD_build", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "modifier-source:MOD_cast", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "modifier-source:MOD_cast_web", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "modifier-source:MOD_cloth", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "modifier-source:MOD_collision", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "modifier-source:MOD_correctivesmooth", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "modifier-source:MOD_curve", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "modifier-source:MOD_datatransfer", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "modifier-source:MOD_decimate", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "modifier-source:MOD_displace", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "modifier-source:MOD_displace_web", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "modifier-source:MOD_dynamicpaint", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "modifier-source:MOD_edgesplit", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "modifier-source:MOD_explode", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "modifier-source:MOD_fluid", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "modifier-source:MOD_grease_pencil_armature", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "modifier-source:MOD_grease_pencil_array", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "modifier-source:MOD_grease_pencil_build", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "modifier-source:MOD_grease_pencil_color", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "modifier-source:MOD_grease_pencil_dash", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "modifier-source:MOD_grease_pencil_envelope", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "modifier-source:MOD_grease_pencil_hook", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "modifier-source:MOD_grease_pencil_lattice", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "modifier-source:MOD_grease_pencil_length", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "modifier-source:MOD_grease_pencil_mirror", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "modifier-source:MOD_grease_pencil_multiply", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "modifier-source:MOD_grease_pencil_noise", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "modifier-source:MOD_grease_pencil_offset", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "modifier-source:MOD_grease_pencil_opacity", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "modifier-source:MOD_grease_pencil_outline", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "modifier-source:MOD_grease_pencil_shrinkwrap", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "modifier-source:MOD_grease_pencil_simplify", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "modifier-source:MOD_grease_pencil_smooth", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "modifier-source:MOD_grease_pencil_subdiv", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "modifier-source:MOD_grease_pencil_texture", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "modifier-source:MOD_grease_pencil_thickness", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "modifier-source:MOD_grease_pencil_time", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "modifier-source:MOD_grease_pencil_tint", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "modifier-source:MOD_grease_pencil_util", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "modifier-source:MOD_grease_pencil_weight_angle", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "modifier-source:MOD_grease_pencil_weight_proximity", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "modifier-source:MOD_hook", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "modifier-source:MOD_laplaciandeform", + "manifestMatches": false, + "productionEvidenceMatches": false + }, + { + "unitId": "modifier-source:MOD_laplaciansmooth", + "manifestMatches": false, + "productionEvidenceMatches": false + }, + { + "unitId": "modifier-source:MOD_lattice", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "modifier-source:MOD_lineart", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "modifier-source:MOD_mask", + "manifestMatches": false, + "productionEvidenceMatches": false + }, + { + "unitId": "modifier-source:MOD_mesh_to_volume", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "modifier-source:MOD_meshcache", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "modifier-source:MOD_meshcache_mdd", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "modifier-source:MOD_meshcache_pc2", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "modifier-source:MOD_meshcache_util", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "modifier-source:MOD_meshdeform", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "modifier-source:MOD_meshsequencecache", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "modifier-source:MOD_mirror", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "modifier-source:MOD_multires", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "modifier-source:MOD_nodes", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "modifier-source:MOD_nodes_web", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "modifier-source:MOD_normal_edit", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "modifier-source:MOD_ocean", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "modifier-source:MOD_particleinstance", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "modifier-source:MOD_particlesystem", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "modifier-source:MOD_remesh", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "modifier-source:MOD_screw", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "modifier-source:MOD_shapekey", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "modifier-source:MOD_shrinkwrap", + "manifestMatches": false, + "productionEvidenceMatches": false + }, + { + "unitId": "modifier-source:MOD_simpledeform", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "modifier-source:MOD_skin", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "modifier-source:MOD_smooth", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "modifier-source:MOD_softbody", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "modifier-source:MOD_solidify", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "modifier-source:MOD_solidify_extrude", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "modifier-source:MOD_solidify_nonmanifold", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "modifier-source:MOD_subsurf", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "modifier-source:MOD_surface", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "modifier-source:MOD_surfacedeform", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "modifier-source:MOD_triangulate", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "modifier-source:MOD_util", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "modifier-source:MOD_uvproject", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "modifier-source:MOD_uvwarp", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "modifier-source:MOD_volume_displace", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "modifier-source:MOD_volume_to_mesh", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "modifier-source:MOD_warp", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "modifier-source:MOD_wave", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "modifier-source:MOD_weighted_normal", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "modifier-source:MOD_weightvg_util", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "modifier-source:MOD_weightvgedit", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "modifier-source:MOD_weightvgmix", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "modifier-source:MOD_weightvgproximity", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "modifier-source:MOD_weld", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "modifier-source:MOD_wireframe", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "node:CompositorNodeAlphaOver", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeAntiAliasing", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeBilateralblur", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeBlankImage", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeBlur", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeBokehBlur", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeBokehImage", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeBoxMask", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeBrightContrast", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeChannelMatte", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeChromaMatte", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeColorBalance", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeColorCorrection", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeColorMatte", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeColorSpill", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeCombineColor", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeConvertColorSpace", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeConvertToDisplay", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeConvolve", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeCornerPin", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeCrop", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeCryptomatte", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeCryptomatteV2", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeCurveRGB", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeDBlur", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeDefocus", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeDenoise", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeDespeckle", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeDiffMatte", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeDilateErode", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeDisplace", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeDistanceMatte", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeDoubleEdgeMask", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeEllipseMask", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeExposure", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "node:CompositorNodeFilter", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeFlip", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeGlare", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeHueCorrect", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeHueSat", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeIDMask", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeImage", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeImageCoordinates", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeImageInfo", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeInpaint", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeInvert", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "node:CompositorNodeKeying", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeKeyingScreen", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeKuwahara", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeLensdist", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeLevels", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeLumaMatte", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeMapUV", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeMask", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeMaskToSDF", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeMovieClip", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeMovieDistortion", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeNormal", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeNormalize", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeOutputFile", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodePixelate", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodePlaneTrackDeform", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodePosterize", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodePremulKey", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeRGB", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "node:CompositorNodeRGBToBW", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeRLayers", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeRelativeToPixel", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeRotate", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeScale", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeSceneTime", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeSeparateColor", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeSequencerStripInfo", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeSetAlpha", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeSplit", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeStabilize", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeStringToImage", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeSwitch", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeSwitchView", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeTime", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeTonemap", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeTrackPos", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeTransform", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeTranslate", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeVecBlur", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeViewer", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:CompositorNodeZcombine", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:FunctionNodeAlignRotationToVector", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:FunctionNodeAxesToRotation", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:FunctionNodeAxisAngleToRotation", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:FunctionNodeCombineMatrix", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:FunctionNodeEulerToRotation", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:FunctionNodeFindInString", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:FunctionNodeFormatString", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:FunctionNodeInputBool", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:FunctionNodeInputInt", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:FunctionNodeInputIntVector", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:FunctionNodeInputMenu", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:FunctionNodeInputRotation", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:FunctionNodeInputSpecialCharacters", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:FunctionNodeInputString", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:FunctionNodeInputVector", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:FunctionNodeInvertMatrix", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:FunctionNodeInvertRotation", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:FunctionNodeMatchString", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:FunctionNodeMatrixDeterminant", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:FunctionNodeMatrixMultiply", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:FunctionNodeProjectPoint", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:FunctionNodeQuaternionToRotation", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:FunctionNodeReplaceString", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:FunctionNodeReverseString", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:FunctionNodeRotateRotation", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:FunctionNodeRotateVector", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:FunctionNodeRotationToAxisAngle", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:FunctionNodeRotationToEuler", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:FunctionNodeRotationToQuaternion", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:FunctionNodeSeparateMatrix", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:FunctionNodeSetStringCase", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:FunctionNodeSliceString", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:FunctionNodeStringLength", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:FunctionNodeStringToValue", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:FunctionNodeTransformDirection", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:FunctionNodeTransformPoint", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:FunctionNodeTransposeMatrix", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:FunctionNodeTrimString", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:FunctionNodeValueToString", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeAccumulateField", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeAttributeDomainSize", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeAttributeStatistic", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeBake", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeBlurAttribute", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeBoneInfo", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeBoundBox", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeCameraInfo", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeCaptureAttribute", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeClosureToList", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeClusterByConnected", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeClusterByDistance", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeCollectionChildren", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeCollectionInfo", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeConvexHull", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeCornersOfEdge", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeCornersOfFace", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeCornersOfVertex", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeCubeGridTopology", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeCurveArc", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeCurveEndpointSelection", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeCurveHandleTypeSelection", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeCurveLength", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeCurveOfPoint", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeCurvePrimitiveBezierSegment", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeCurvePrimitiveCircle", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeCurvePrimitiveLine", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeCurvePrimitiveQuadrilateral", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeCurveQuadraticBezier", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeCurveSetHandles", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeCurveSpiral", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeCurveSplineType", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeCurveStar", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeCurveToMesh", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeCurveToPoints", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeCurvesToGreasePencil", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeDeformCurvesOnSurface", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeDeleteGeometry", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeDistributePointsInGrid", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeDistributePointsInVolume", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeDistributePointsOnFaces", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeDualMesh", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeDuplicateElements", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeEdgePathsToCurves", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeEdgePathsToSelection", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeEdgesOfCorner", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeEdgesOfVertex", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeEdgesToFaceGroups", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeExtrudeMesh", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeFaceOfCorner", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeFieldAtIndex", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeFieldAverage", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeFieldMinAndMax", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeFieldOnDomain", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeFieldToGrid", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeFieldToList", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeFieldVariance", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeFillCurve", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeFilletCurve", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeFilterList", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeFlipFaces", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeForeachGeometryElementInput", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeForeachGeometryElementOutput", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeGeometryToInstance", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeGetAttributeNames", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeGetGeometryBundle", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeGetGeometryComponent", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeGetNamedGrid", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeGizmoDial", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeGizmoLinear", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeGizmoTransform", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeGreasePencilToCurves", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeGridAdvect", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeGridClip", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeGridCurl", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeGridDilateAndErode", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeGridDivergence", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeGridGradient", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeGridInfo", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeGridLaplacian", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeGridMean", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeGridMedian", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeGridPrune", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeGridToMesh", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeGridToPoints", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeGridVoxelize", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeImageInfo", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeImageTexture", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeImportCSV", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeImportOBJ", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeImportPLY", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeImportSTL", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeImportText", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeImportVDB", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeIndexOfNearest", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeIndexSwitch", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeInputActiveCamera", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeInputCollection", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeInputCurveHandlePositions", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeInputCurveTilt", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeInputEdgeSmooth", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeInputFont", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeInputID", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeInputImage", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeInputIndex", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeInputInstanceBounds", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeInputInstanceReference", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeInputInstanceRotation", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeInputInstanceScale", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeInputMaterial", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeInputMaterialIndex", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeInputMeshEdgeAngle", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeInputMeshEdgeNeighbors", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeInputMeshEdgeVertices", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeInputMeshFaceArea", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeInputMeshFaceIsPlanar", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeInputMeshFaceNeighbors", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeInputMeshIsland", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeInputMeshVertexNeighbors", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeInputNamedAttribute", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeInputNamedLayerSelection", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeInputNormal", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeInputObject", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeInputPosition", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeInputRadius", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeInputSceneTime", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeInputShadeSmooth", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeInputShortestEdgePaths", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeInputSplineCyclic", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeInputSplineResolution", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeInputTangent", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeInputVoxelIndex", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeInstanceOnPoints", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeInstanceTransform", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeInstancesToPoints", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeInterpolateCurves", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeIsViewport", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeJoinGeometry", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeListGetItem", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeListLength", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeMaterialSelection", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeMenuSwitch", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeMergeByDistance", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeMergeLayers", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeMergePoints", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeMeshBevel", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeMeshBoolean", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeMeshCircle", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeMeshCone", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeMeshCube", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeMeshCylinder", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeMeshFaceSetBoundaries", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeMeshGrid", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeMeshIcoSphere", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeMeshLine", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeMeshToCurve", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeMeshToDensityGrid", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeMeshToPoints", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeMeshToSDFGrid", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeMeshToVolume", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeMeshUVSphere", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeObjectInfo", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeOffsetCornerInFace", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeOffsetPointInCurve", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodePoints", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodePointsOfCurve", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodePointsToCurves", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodePointsToSDFGrid", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodePointsToVertices", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodePointsToVolume", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeProximity", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeRaycast", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeRealizeInstances", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeRemoveAttribute", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeRenameAttribute", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeRepeatInput", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeRepeatOutput", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeReplaceMaterial", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeResampleCurve", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeReverseCurve", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeRotateInstances", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeSDFGridBoolean", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeSDFGridFillet", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeSDFGridLaplacian", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeSDFGridMean", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeSDFGridMeanCurvature", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeSDFGridMedian", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeSDFGridOffset", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeSampleCurve", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeSampleGrid", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeSampleGridIndex", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeSampleIndex", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeSampleNearest", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeSampleNearestSurface", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeSampleSoundFrequencies", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeSampleUVSurface", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeScaleElements", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeScaleInstances", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeSelfObject", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeSeparateComponents", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeSeparateGeometry", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeSetCurveHandlePositions", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeSetCurveNormal", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeSetCurveRadius", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeSetCurveTilt", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeSetGeometryBundle", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeSetGeometryName", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeSetGreasePencilColor", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeSetGreasePencilDepth", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeSetGreasePencilSoftness", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeSetGridBackground", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeSetGridTransform", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeSetID", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeSetInstanceTransform", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeSetMaterial", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeSetMaterialIndex", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeSetMeshNormal", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeSetNURBSOrder", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeSetNURBSWeight", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeSetPointRadius", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeSetPosition", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeSetShadeSmooth", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeSetSplineCyclic", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeSetSplineResolution", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeSimulationInput", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeSimulationOutput", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeSortElements", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeSortList", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeSplineLength", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeSplineParameter", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeSplitEdges", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeSplitToInstances", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeStoreNamedAttribute", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeStoreNamedGrid", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeStringJoin", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeStringToCurves", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeSubdivideCurve", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeSubdivideMesh", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeSubdivisionSurface", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeSwitch", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeTagFilter", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeTool3DCursor", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeToolActiveElement", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeToolFaceSet", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeToolMousePosition", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeToolSelection", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeToolSetFaceSet", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeToolSetSelection", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeTransferAttributes", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeTransform", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeTranslateInstances", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeTriangulate", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeTrimCurve", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeUVPackIslands", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeUVTangent", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeUVUnwrap", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeVertexOfCorner", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeViewer", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeViewportTransform", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeVolumeCube", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeVolumeToMesh", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeWarning", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:GeometryNodeXPBDSolver", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:NodeClosureInput", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:NodeClosureOutput", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:NodeCombineBundle", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:NodeEnableOutput", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:NodeEvaluateClosure", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:NodeGetBundleItem", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:NodeGetNestedBundlePaths", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:NodeJoinBundle", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:NodeSeparateBundle", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:NodeStoreBundleItem", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeAddShader", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeAmbientOcclusion", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeAttribute", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeBackground", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeBevel", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeBlackbody", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeBrightContrast", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeBsdfAnisotropic", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeBsdfDiffuse", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeBsdfGlass", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeBsdfHair", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeBsdfHairPrincipled", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeBsdfMetallic", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeBsdfPrincipled", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "node:ShaderNodeBsdfRayPortal", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeBsdfRefraction", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeBsdfSheen", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeBsdfToon", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeBsdfTranslucent", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeBsdfTransparent", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeBump", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeCameraData", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeClamp", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeCombineColor", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeCombineXYZ", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeDisplacement", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeEeveeSpecular", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeEmission", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeFloatCurve", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeFresnel", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeGamma", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeHairInfo", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeHoldout", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeHueSaturation", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeInvert", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeLayerWeight", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeLightFalloff", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeLightPath", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeMapRange", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeMapping", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeMath", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeMix", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeMixRGB", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeMixShader", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeNewGeometry", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeNormal", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeNormalMap", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeObjectInfo", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeOutputAOV", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeOutputLight", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeOutputLineStyle", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeOutputMaterial", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "node:ShaderNodeOutputWorld", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeParticleInfo", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodePointInfo", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeRGB", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeRGBCurve", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeRGBToBW", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeRadialTiling", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeRaycast", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeScript", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeSeparateColor", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeSeparateXYZ", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeShaderToRGB", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeSqueeze", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeSubsurfaceScattering", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeTangent", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeTexBrick", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeTexChecker", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeTexCoord", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeTexEnvironment", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeTexGabor", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeTexGradient", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeTexIES", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeTexImage", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeTexMagic", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeTexNoise", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeTexSky", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeTexVoronoi", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeTexWave", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeTexWhiteNoise", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeUVAlongStroke", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeUVMap", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeValToRGB", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeValue", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeVectorCurve", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeVectorDisplacement", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeVectorMath", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeVectorRotate", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeVectorTransform", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeVertexColor", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeVolumeAbsorption", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeVolumeCoefficients", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeVolumeInfo", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeVolumePrincipled", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeVolumeScatter", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeWavelength", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "node:ShaderNodeWireframe", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "operator:ANIM_OT_change_frame", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "operator:MESH_OT_bevel", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "operator:MESH_OT_decimate", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "operator:MESH_OT_dissolve_edges", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "operator:MESH_OT_extrude_region", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "operator:MESH_OT_inset", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "operator:MESH_OT_loopcut", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "operator:MESH_OT_merge", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "operator:MESH_OT_primitive_cube_add", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "operator:OBJECT_OT_collection_add", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "operator:OBJECT_OT_delete", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "operator:OBJECT_OT_duplicate", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "operator:OBJECT_OT_hide_view_clear", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "operator:OBJECT_OT_hide_view_set", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "operator:OBJECT_OT_join", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "operator:OBJECT_OT_location_clear", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "operator:OBJECT_OT_material_slot_add", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "operator:OBJECT_OT_material_slot_assign", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "operator:OBJECT_OT_material_slot_remove", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "operator:OBJECT_OT_move_to_collection", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "operator:OBJECT_OT_parent_set", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "operator:OBJECT_OT_rotation_clear", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "operator:OBJECT_OT_scale_clear", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "operator:OBJECT_OT_transform_apply", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "operator:UV_OT_unwrap", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "operator:WM_OT_obj_export", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "operator:WM_OT_obj_import", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "operator:WM_OT_ply_export", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "operator:WM_OT_ply_import", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "operator:WM_OT_stl_export", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "operator:WM_OT_stl_import", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:AOV", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:AOVs", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:Action", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:ActionChannelbag", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:ActionChannelbagFCurves", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:ActionChannelbagGroups", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:ActionChannelbags", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:ActionGroup", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:ActionKeyframeStrip", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:ActionLayer", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:ActionLayers", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:ActionPoseMarkers", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:ActionSlot", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:ActionSlots", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:ActionStrip", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:ActionStrips", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:AnimData", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:AnimDataDrivers", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:Area", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:AreaLight", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:Armature", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:ArmatureModifier", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:ArrayModifier", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:Attribute", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:AttributeGroupCurves", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:AttributeGroupMesh", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:AttributeGroupPointCloud", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:BevelModifier", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:BezierSplinePoint", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:BlendDataActions", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:BlendDataArmatures", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:BlendDataBrushes", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:BlendDataCameras", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:BlendDataCollections", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:BlendDataCurves", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:BlendDataFonts", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:BlendDataGreasePencilsV3", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:BlendDataHairCurves", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:BlendDataImages", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:BlendDataLattices", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:BlendDataLibraries", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:BlendDataLights", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:BlendDataLineStyles", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:BlendDataMaterials", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:BlendDataMeshes", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:BlendDataMetaBalls", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:BlendDataNodeTrees", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:BlendDataObjects", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:BlendDataParticles", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:BlendDataPointClouds", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:BlendDataScenes", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:BlendDataSounds", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:BlendDataSpeakers", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:BlendDataTexts", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:BlendDataTextures", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:BlendDataVolumes", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:BlendDataWorkSpaces", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:BlendDataWorlds", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:Bone", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:BooleanModifier", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:BuildModifier", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:Camera", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:CameraDOFSettings", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:CastModifier", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:ChannelDriverVariables", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:ClothModifier", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:Collection", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:CollectionChild", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:CollectionChildren", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:CollectionObject", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:CollectionObjects", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:CollisionModifier", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:ColorManagedDisplaySettings", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:ColorManagedViewSettings", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:CompositorNode", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:CompositorNodeTree", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:Constraint", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:CorrectiveSmoothModifier", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:Curve", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:CurveModifier", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:CurvePoint", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:CurveSplines", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:DataTransferModifier", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:DecimateModifier", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:Depsgraph", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:DisplaceModifier", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:Driver", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:DriverTarget", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:DriverVariable", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:DynamicPaintModifier", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:EdgeSplitModifier", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:ExplodeModifier", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:FCurve", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:FCurveKeyframePoints", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:FCurveModifiers", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:FCurveSample", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:FModifier", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:FModifierCycles", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:FModifierEnvelope", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:FModifierGenerator", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:FModifierLimits", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:FModifierNoise", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:FModifierSmooth", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:FModifierStepped", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:FluidDomainSettings", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:FluidModifier", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:FreestyleLineStyle", + "manifestMatches": false, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:GeometryNode", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:GeometryNodeTree", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:GreasePencil", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:GreasePencilArmatureModifier", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:GreasePencilArrayModifier", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:GreasePencilBuildModifier", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:GreasePencilColorModifier", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:GreasePencilDrawing", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:GreasePencilEnvelopeModifier", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:GreasePencilFrame", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:GreasePencilFrames", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:GreasePencilHookModifier", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:GreasePencilLatticeModifier", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:GreasePencilLayer", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:GreasePencilLengthModifier", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:GreasePencilLineartModifier", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:GreasePencilMirrorModifier", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:GreasePencilMultiplyModifier", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:GreasePencilNoiseModifier", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:GreasePencilOffsetModifier", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:GreasePencilOpacityModifier", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:GreasePencilOutlineModifier", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:GreasePencilShrinkwrapModifier", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:GreasePencilSimplifyModifier", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:GreasePencilSmoothModifier", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:GreasePencilSubdivModifier", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:GreasePencilTextureModifier", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:GreasePencilTimeModifier", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:GreasePencilTintModifier", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:GreasePencilWeightAngleModifier", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:GreasePencilWeightProximityModifier", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:GreasePencilv3Layers", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:HookModifier", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:IDMaterials", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:Image", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:ImageFormatSettings", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:Key", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:Keyframe", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:LaplacianDeformModifier", + "manifestMatches": false, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:LaplacianSmoothModifier", + "manifestMatches": false, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:Lattice", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:LatticeModifier", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:Light", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:Lightgroups", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:LineStyleAlphaModifier", + "manifestMatches": false, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:LineStyleAlphaModifier_AlongStroke", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:LineStyleAlphaModifier_CreaseAngle", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:LineStyleAlphaModifier_Curvature_3D", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:LineStyleAlphaModifier_DistanceFromCamera", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:LineStyleAlphaModifier_DistanceFromObject", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:LineStyleAlphaModifier_Material", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:LineStyleAlphaModifier_Noise", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:LineStyleAlphaModifier_Tangent", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:LineStyleAlphaModifiers", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:LineStyleColorModifier", + "manifestMatches": false, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:LineStyleColorModifier_AlongStroke", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:LineStyleColorModifier_CreaseAngle", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:LineStyleColorModifier_Curvature_3D", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:LineStyleColorModifier_DistanceFromCamera", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:LineStyleColorModifier_DistanceFromObject", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:LineStyleColorModifier_Material", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:LineStyleColorModifier_Noise", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:LineStyleColorModifier_Tangent", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:LineStyleColorModifiers", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:LineStyleGeometryModifier", + "manifestMatches": false, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:LineStyleGeometryModifier_2DOffset", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:LineStyleGeometryModifier_2DTransform", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:LineStyleGeometryModifier_BackboneStretcher", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:LineStyleGeometryModifier_BezierCurve", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:LineStyleGeometryModifier_Blueprint", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:LineStyleGeometryModifier_GuidingLines", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:LineStyleGeometryModifier_PerlinNoise1D", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:LineStyleGeometryModifier_PerlinNoise2D", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:LineStyleGeometryModifier_Polygonalization", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:LineStyleGeometryModifier_Sampling", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:LineStyleGeometryModifier_Simplification", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:LineStyleGeometryModifier_SinusDisplacement", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:LineStyleGeometryModifier_SpatialNoise", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:LineStyleGeometryModifier_TipRemover", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:LineStyleGeometryModifiers", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:LineStyleModifier", + "manifestMatches": false, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:LineStyleThicknessModifier", + "manifestMatches": false, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:LineStyleThicknessModifier_AlongStroke", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:LineStyleThicknessModifier_Calligraphy", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:LineStyleThicknessModifier_CreaseAngle", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:LineStyleThicknessModifier_Curvature_3D", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:LineStyleThicknessModifier_DistanceFromCamera", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:LineStyleThicknessModifier_DistanceFromObject", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:LineStyleThicknessModifier_Material", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:LineStyleThicknessModifier_Noise", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:LineStyleThicknessModifier_Tangent", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:LineStyleThicknessModifiers", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:Mask", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:MaskLayer", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:MaskLayers", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:MaskModifier", + "manifestMatches": false, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:MaskSpline", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:MaskSplinePoint", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:MaskSplinePoints", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:MaskSplines", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:Material", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:MaterialSlot", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:Mesh", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:MeshCacheModifier", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:MeshDeformModifier", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:MeshEdges", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:MeshLoops", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:MeshPolygon", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:MeshPolygons", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:MeshSequenceCacheModifier", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:MeshToVolumeModifier", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:MeshUVLoopLayer", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:MeshVertex", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:MeshVertices", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:MetaBall", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:MetaBallElements", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:MetaElement", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:MirrorModifier", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:Modifier", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:MultiresModifier", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:NlaStrip", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:NlaStrips", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:NlaTrack", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:NlaTracks", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:Node", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:NodeLink", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:NodeLinks", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:NodeTree", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:Nodes", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:NodesModifier", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:NormalEditModifier", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:Object", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:ObjectConstraints", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:ObjectModifiers", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:OceanModifier", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:ParticleInstanceModifier", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:ParticleSettings", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:ParticleSystemModifier", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:Point", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:PointCloud", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:PointLight", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:Pose", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:PoseBone", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:RemeshModifier", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:RenderSettings", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:Scene", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:SceneObjects", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:SceneRenderView", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:ScrewModifier", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:ShaderNode", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:ShaderNodeTree", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:ShapeKey", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:ShapeKeyPoint", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:ShrinkwrapModifier", + "manifestMatches": false, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:SimpleDeformModifier", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:SkinModifier", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:SmoothModifier", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:SoftBodyModifier", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:SolidifyModifier", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:Sound", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:Speaker", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:Spline", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:SplineBezierPoints", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:SplinePoint", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:SplinePoints", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:SpotLight", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:SubsurfModifier", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:SunLight", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:SurfaceCurve", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:SurfaceDeformModifier", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:SurfaceModifier", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:Text", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:TextBox", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:TextCharacterFormat", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:TextCurve", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:TextLine", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:Texture", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:TriangulateModifier", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:UVProjectModifier", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:UVWarpModifier", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:UnitSettings", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:VertexWeightEditModifier", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:VertexWeightMixModifier", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:VertexWeightProximityModifier", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:ViewLayer", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:ViewLayers", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:Volume", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:VolumeDisplaceModifier", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:VolumeDisplay", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:VolumeRender", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:VolumeToMeshModifier", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:WarpModifier", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:WaveModifier", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:WeightedNormalModifier", + "manifestMatches": false, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:WeldModifier", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:WireframeModifier", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "rna-struct:World", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:WorldLighting", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "rna-struct:WorldMistSettings", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "web-command:addMaterialSlot", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:applyObjectTransform", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "web-command:assignMaterialFaces", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:createCollection", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "web-command:createCurve", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:createGreasePencilLayer", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:createPrimitive", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:createUVMap", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:decimateMesh", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:deleteNonMeshData", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:deleteObject", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "web-command:deleteObjectKeyframe", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:duplicateObject", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:importImage", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:importVFont", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "web-command:insertGreasePencilFrame", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:insertObjectKeyframe", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:joinObjects", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:meshEdit", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:moveGreasePencilFrame", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:moveGreasePencilLayer", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:moveObjectToCollection", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "web-command:removeGreasePencilFrame", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:removeGreasePencilLayer", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:removeMaterialSlot", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:renameId", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "web-command:sculptStroke", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:separateMeshFaces", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:setActiveAction", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:setActiveUVMap", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:setCameraProperties", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "web-command:setConstraint", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:setCurveControlPoints", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:setCurveHandle", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:setCurveSplines", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:setCurveTopology", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:setFCurveInterpolation", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:setFontAdvanced", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:setFontBody", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:setFontLinks", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:setFontProperties", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:setFrame", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "web-command:setGeometryNodeGraph", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "web-command:setGreasePencilStrokes", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:setLightProperties", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "web-command:setMaterialImageNode", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:setMaterialPrincipled", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:setMetaballElements", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:setModifierEnabled", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:setModifierVisibility", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:setNLAStack", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:setObjectLightgroup", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:setObjectOrigin", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:setObjectTransform", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:setObjectVisibility", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:setParent", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:setParticleSettings", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "web-command:setPhysicsSimulation", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:setSceneAudioSettings", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:setSceneBindings", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:setSceneBorderSettings", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:setSceneCollectionSettings", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:setSceneColorManagement", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:setSceneCompositorSettings", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:setSceneHairSettings", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:setSceneImageFormat", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:setSceneLineSettings", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:setSceneMotionBlur", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:setSceneMultiviewSettings", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:setScenePerformanceSettings", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:setScenePipelineSettings", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:setSceneProperties", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:setSceneRenderSettings", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:setSceneSamplingSettings", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:setSceneSimplifySettings", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:setSceneStampSettings", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:setSceneTimelineSettings", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:setSceneUnitSettings", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:setSceneViewLayerAOVs", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:setSceneViewLayerLightgroups", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:setSceneViewLayerPassSettings", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:setSceneViewLayerSettings", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:setSculptMeshAttributes", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:setShaderGraph", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "web-command:setSoundProperties", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "web-command:setSpeakerProperties", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "web-command:setSurfaceTopology", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:setTextSource", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:setTextureProperties", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:setVertexColors", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "web-command:setVertexWeights", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "web-command:setVolumeProperties", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:setWorldLightgroup", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:setWorldProperties", + "manifestMatches": true, + "productionEvidenceMatches": true + }, + { + "unitId": "web-command:translateMeshVertices", + "manifestMatches": true, + "productionEvidenceMatches": false + }, + { + "unitId": "web-command:unwrapUV", + "manifestMatches": true, + "productionEvidenceMatches": false + } + ] +} diff --git a/tests/golden/WBV2-P1424-001/deployed-audit/f3-server-result.png b/tests/golden/WBV2-P1424-001/deployed-audit/f3-server-result.png new file mode 100644 index 000000000..d635ca728 Binary files /dev/null and b/tests/golden/WBV2-P1424-001/deployed-audit/f3-server-result.png differ diff --git a/tests/golden/WBV2-P1424-001/deployed-audit/roundtrip.blend b/tests/golden/WBV2-P1424-001/deployed-audit/roundtrip.blend new file mode 100644 index 000000000..b0b6728b6 Binary files /dev/null and b/tests/golden/WBV2-P1424-001/deployed-audit/roundtrip.blend differ diff --git a/tests/golden/WBV2-P1424-001/manifest.json b/tests/golden/WBV2-P1424-001/manifest.json index 216e22195..03f9e9c70 100644 --- a/tests/golden/WBV2-P1424-001/manifest.json +++ b/tests/golden/WBV2-P1424-001/manifest.json @@ -2,10 +2,11 @@ "schemaVersion": 1, "task": "WBV2-P1424-001", "parentTask": "WBV2-P1424-000", - "operation": "WEB_PRODUCT_IMPLEMENTATION_COMPLETE", - "status": "done", + "operation": "WEB_PRODUCT_RUNTIME_CLOSURE_CHECKPOINT", + "status": "in_progress", "implementationComplete": true, - "verificationDeferred": true, + "verificationDeferred": false, + "acceptanceComplete": false, "artifacts": { "parentManifest": { "path": "tests/golden/WBV2-P1424-000/manifest.json", @@ -25,7 +26,7 @@ }, "status": { "path": "docs/status/WBV2-P1424-001.md", - "sha256": "570be0c64b5e05b534262b6932282f4b9984ca218e1e26719b8cacee39190cdc" + "sha256": "afdfe45e55c68a8c62956d5e075b522055b0fb8edefe37a480f830eabce2cf29" }, "plan": { "path": "tests/golden/WBV2-P1424-000/runtime-closure-plan.json", @@ -33,7 +34,11 @@ }, "taskContext": { "path": "tests/golden/WBV2-P1424-001/task-context.json", - "sha256": "f97153c590b294b8fa03dbd34c1bed8cd2808550aef549f6a37dfb7deb00ecb6" + "sha256": "77c7e929437b3588f05d62c3106d198fe4e326da85d230ee74c13ec0f050aa87" + }, + "resumeReport": { + "path": "tests/golden/WBV2-P1424-001/resume-report.json", + "sha256": "9b96bfcc5ca87ab052b87c03cba0f146c21af2ce9a4e6b07edf164b97581e891" } }, "nextTask": null diff --git a/tests/golden/WBV2-P1424-001/performance-optimization-report.json b/tests/golden/WBV2-P1424-001/performance-optimization-report.json new file mode 100644 index 000000000..678536d62 --- /dev/null +++ b/tests/golden/WBV2-P1424-001/performance-optimization-report.json @@ -0,0 +1,201 @@ +{ + "schemaVersion": 1, + "operation": "AUTOPILOT_PERFORMANCE_OPTIMIZATION", + "observedAt": "2026-09-08 10:52", + "timezone": "Asia/Shanghai", + "labelPrecision": "minute", + "baseline": { + "schemaVersion": 1, + "observedAt": "2026-09-08 10:52", + "timezone": "Asia/Shanghai", + "labelPrecision": "minute", + "totalMeasuredMinutes": 14.1828, + "summary": [ + { + "phase": "model_request", + "count": 2, + "seconds": 845.907, + "maxSeconds": 688.854, + "minutes": 14.0985, + "sharePercent": 99.41 + }, + { + "phase": "context_check", + "count": 4, + "seconds": 4.02, + "maxSeconds": 1.006, + "minutes": 0.067, + "sharePercent": 0.47 + }, + { + "phase": "git_ls-files", + "count": 1, + "seconds": 1.007, + "maxSeconds": 1.007, + "minutes": 0.0168, + "sharePercent": 0.12 + }, + { + "phase": "git_diff", + "count": 1, + "seconds": 0.029, + "maxSeconds": 0.029, + "minutes": 0.0005, + "sharePercent": 0.0 + }, + { + "phase": "git_rev-parse", + "count": 1, + "seconds": 0.002, + "maxSeconds": 0.002, + "minutes": 0.0, + "sharePercent": 0.0 + } + ], + "steps": [ + { + "phase": "git_diff", + "start": "2026-09-08 10:10", + "finish": "2026-09-08 10:10", + "seconds": 0.029, + "minutes": 0.0005, + "exitCode": 0, + "log": "tests/golden/WBV2/autopilot/git/638a9273e10249f98ef046be57a81b32.log", + "providerAbort": null + }, + { + "phase": "git_ls-files", + "start": "2026-09-08 10:10", + "finish": "2026-09-08 10:10", + "seconds": 1.007, + "minutes": 0.0168, + "exitCode": 0, + "log": "tests/golden/WBV2/autopilot/git/f4402401e72c4c958f487095a6561c1f.log", + "providerAbort": null + }, + { + "phase": "git_rev-parse", + "start": "2026-09-08 10:10", + "finish": "2026-09-08 10:10", + "seconds": 0.002, + "minutes": 0.0, + "exitCode": 0, + "log": "tests/golden/WBV2/autopilot/git/b3a0220f89e34fe693cf6ddcddc331aa.log", + "providerAbort": null + }, + { + "phase": "context_check", + "start": "2026-09-08 10:10", + "finish": "2026-09-08 10:10", + "seconds": 1.006, + "minutes": 0.0168, + "exitCode": 0, + "log": "tests/golden/WBV2/autopilot/preflight-0.log", + "providerAbort": null + }, + { + "phase": "context_check", + "start": "2026-09-08 10:10", + "finish": "2026-09-08 10:10", + "seconds": 1.004, + "minutes": 0.0167, + "exitCode": 0, + "log": "tests/golden/WBV2/autopilot/preflight-1.log", + "providerAbort": null + }, + { + "phase": "model_request", + "start": "2026-09-08 10:10", + "finish": "2026-09-08 10:21", + "seconds": 688.854, + "minutes": 11.4809, + "exitCode": 1, + "log": "tests/golden/WBV2/autopilot/runs/SERVER-OPERATOR-HTTP-PROVIDER-2b37d20fd07b/worker.jsonl", + "providerAbort": null + }, + { + "phase": "context_check", + "start": "2026-09-08 10:21", + "finish": "2026-09-08 10:21", + "seconds": 1.005, + "minutes": 0.0167, + "exitCode": 0, + "log": "tests/golden/WBV2/autopilot/preflight-0.log", + "providerAbort": null + }, + { + "phase": "context_check", + "start": "2026-09-08 10:21", + "finish": "2026-09-08 10:21", + "seconds": 1.005, + "minutes": 0.0167, + "exitCode": 0, + "log": "tests/golden/WBV2/autopilot/preflight-1.log", + "providerAbort": null + }, + { + "phase": "model_request", + "start": "2026-09-08 10:21", + "finish": "2026-09-08 10:24", + "seconds": 157.053, + "minutes": 2.6176, + "exitCode": 0, + "log": "tests/golden/WBV2/autopilot/runs/SERVER-OPERATOR-HTTP-PROVIDER-4683ba870ac5/worker.jsonl", + "providerAbort": null + } + ], + "workers": [], + "current": {}, + "accounting": "Top-level measured spans only; worker item durations are nested and must not be added again. Legacy logs cannot recover per-event timing or unrecorded gaps." + }, + "benchmark": { + "scope": "Same read-only context entrypoints: historical observed baseline versus three current samples per entrypoint; not whole-project throughput.", + "samples": [ + { + "script": "check-task-context.mjs", + "seconds": 0.035114 + }, + { + "script": "check-task-context.mjs", + "seconds": 0.033912 + }, + { + "script": "check-task-context.mjs", + "seconds": 0.033473 + }, + { + "script": "check-context-governance.mjs", + "seconds": 0.065781 + }, + { + "script": "check-context-governance.mjs", + "seconds": 0.033451 + }, + { + "script": "check-context-governance.mjs", + "seconds": 0.065589 + } + ], + "baselineMedianMinutes": 0.01675, + "optimizedMedianMinutes": 0.000575, + "observedSpeedup": 29.12, + "observedReductionPercent": 96.57 + }, + "providerPolicy": { + "modelStartTimeoutSeconds": 60, + "modelIdleTimeoutSeconds": 180, + "providerBackoffSeconds": 30, + "providerMaxBackoffSeconds": 240, + "maxProviderFailures": 4 + }, + "sourcePolicy": { + "driver": "business_module_and_function_route", + "authority": "blender-5.2.0/source/blender", + "sourceFirst": true + }, + "limitations": [ + "Provider availability/account concurrency is external; these changes do not remove upstream limits.", + "No source capability completion or inventory increment is claimed.", + "Legacy JSONL lacks per-item timestamps; new runs record observed per-item intervals separately." + ] +} diff --git a/tests/golden/WBV2-P1424-001/performance-optimization-report.md b/tests/golden/WBV2-P1424-001/performance-optimization-report.md new file mode 100644 index 000000000..92855a5b0 --- /dev/null +++ b/tests/golden/WBV2-P1424-001/performance-optimization-report.md @@ -0,0 +1,53 @@ +# 无人值守执行耗时与优化 + +统计日期：2026-09-08。所有时间标签为北京时间，精确到分钟。 + +| 步骤 | 开始 | 结束 | 耗时（分钟） | 结果 | +| --- | --- | --- | ---: | --- | +| Git 基线准备 | 10:10 | 10:10 | 0.0173 | 完成 | +| 首轮上下文与治理检查 | 10:10 | 10:10 | 0.0335 | 通过 | +| 首次模型请求 | 10:10 | 10:21 | 11.4809 | 服务过载，退出 1，未执行代理操作 | +| 第二轮上下文与治理检查 | 10:21 | 10:21 | 0.0335 | 通过 | +| 第二次模型请求 | 10:21 | 10:24 | 2.6176 | 账号并发限制，维护暂停，未完成代理回合 | +| 代码修改、源码构建、Chromium 验收、交接 | 未开始 | 未开始 | 未产生样本 | 不计为完成 | + +两次模型请求共占已测步骤耗时的 99.41%。旧日志没有逐事件时间戳， +未记录的重试和调度间隔不能伪造为已测步骤。主因是外部模型服务过载与 +账号并发限制，尚无证据表明编译或浏览器测试是当前瓶颈。 + +## 已实施优化 + +- 新增分阶段计时和逐项事件观测，区分模型等待、读取、修改、命令、构建、 + 各类验收、证据哈希、重试退避和 Git 交接；嵌套耗时不重复累计。 +- 没有代理操作时，明确过载或限流立即结束等待进程；无首次操作上限为 + 1 分钟。通过事件记录和源码哈希确认没有操作后才允许自动重试。 +- 服务故障使用独立预算，按 0.5、1、2、最多 4 分钟退避，连续 4 次失败 + 停在 `provider_blocked`，不消耗功能实现尝试，不推进完成状态。 +- 短命令等待进程结束，不再固定休眠 1 秒；心跳按配置间隔写入，重复证据 + 路径在单次指纹计算中只读取一次。 +- 相同上下文检查的新样本中位耗时为 0.000575 分钟，旧样本为 0.016750 + 分钟，减少 96.57%，约 29.12 倍。此比较不是整个项目的吞吐量提升。 +- 保持源码构建、类型检查、lint、Chromium、正负例、undo/redo、save/reopen + 和确定性验收；没有通过减少功能验收来获得加速。 + +## 执行铁律 + +由功能模块业务与功能路由驱动移植，先检索用户提供的 Blender 源码和 +相关资料，再解决 Web 实现问题。根 `AGENTS.md`、调度策略、代理契约和 +验收记录均已绑定此规则，要求记录工作流、具体路由和原生源码文件。 + +验证：33 项监督程序回归测试、11 项上下文治理测试通过。本段新增源码 +覆盖为 0；动态 inventory 为 3802 单元，账面已验证 1025、未验证 2777， +其中 902 个已验证单元的旧证据引用有漂移。sourceTreeSha256： +`311791df5e2b96c31ee9cefd5ab0c9a8ded87309f1a814c3b92dec328a607d6a`。 + +可复查命令： + +```bash +python3 my-tools/run_web_product_migration.py timings +python3 my-tools/run_web_product_migration.py timings --json --write +python3 my-tools/benchmark_wbv2_autopilot.py +``` + +优化减少无效等待并改善调度开销，不能消除外部账号并发限制。移植任务 +仍为 `WBV2-P1424-001`，完整行为验收未完成，队列没有推进。 diff --git a/tests/golden/WBV2-P1424-001/resume-report.json b/tests/golden/WBV2-P1424-001/resume-report.json new file mode 100644 index 000000000..5e6c2e857 --- /dev/null +++ b/tests/golden/WBV2-P1424-001/resume-report.json @@ -0,0 +1,73 @@ +{ + "schemaVersion": 1, + "task": "WBV2-P1424-001", + "parentTask": "WBV2-P1424-000", + "operation": "RUNTIME_CLOSURE_HANDOFF_RECONCILIATION", + "observedOn": "2026-09-08", + "status": "in_progress", + "acceptanceComplete": false, + "queueAdvanced": false, + "nextTask": null, + "implementation": { + "previousReport": "tests/golden/WBV2-P1424-001/product-implementation-report.json", + "reportedTasks": 34, + "reportedImplementedTasks": 34, + "reportedWorkflowModules": 16, + "newCapabilities": 0, + "productionCommandsReplayed": false + }, + "sourceInventory": { + "manifestPath": "tests/golden/WBV2/dynamic-inventory-manifest.json", + "manifestSha256": "bf3e5de1ddc5569a19445a4ca88a5da32ce32b330082d42f8d17467d76d57ed2", + "basis": "existing source inventory reported by check-execution-control-plane; not regenerated in this reconciliation", + "unitCount": 3802, + "verifiedUnits": 1025, + "unverifiedUnits": 2777, + "sourceTreeSha256": "311791df5e2b96c31ee9cefd5ab0c9a8ded87309f1a814c3b92dec328a607d6a", + "boundUnitDelta": 0, + "previousImplementationReportUnitCount": 3745 + }, + "checks": [ + { "command": "node tools/web/print-task-context.mjs", "exitCode": 0 }, + { "command": "node tools/web/check-task-context.mjs", "exitCode": 0 }, + { "command": "npm --prefix web run test:task-context", "exitCode": 0, "passedTests": 6 }, + { "command": "npm --prefix web run test:context-governance", "exitCode": 0, "passedTests": 11 }, + { "command": "node tools/web/check-execution-control-plane.mjs", "exitCode": 0 }, + { "command": "node tools/web/check-task-index.mjs", "exitCode": 0 }, + { "command": "node tools/web/check-blender-next-task-plan.mjs", "exitCode": 1 }, + { "command": "node tools/web/run-wbv2-scheduler.mjs --preflight-only", "exitCode": 0, "output": "empty; no runtime acceptance evidence" }, + { "command": "node tools/web/check-task-context.mjs --task WBV2-P1424-001 --write", "exitCode": 0 }, + { "command": "git diff --check", "exitCode": 0 } + ], + "repairedEvidence": { + "path": "tests/golden/WBV2-P1424-001/task-context.json", + "previousManifestSha256": "f97153c590b294b8fa03dbd34c1bed8cd2808550aef549f6a37dfb7deb00ecb6", + "regeneratedSha256": "77c7e929437b3588f05d62c3106d198fe4e326da85d230ee74c13ec0f050aa87", + "regenerationChangedBytes": false + }, + "remainingBlockers": [ + { + "code": "PLAN_ARTIFACT_HASH_DRIFT", + "command": "node tools/web/check-blender-next-task-plan.mjs", + "path": "web/package.json", + "expectedSha256": "40b7f14d4f568ae94bedde83e02115c127e0c714e5eb32a6a97b1e1084c4fa68", + "actualSha256": "b334ff7ab822bd9a9c6ad1302fdb6432648f26d1cf1dbfe86825c2cf1947387e", + "recovery": "Reconcile this gate through an authorized current evidence generator without rewriting historical inventory/provenance or reverting existing workspace changes." + }, + { + "code": "RUNTIME_ACCEPTANCE_NOT_BOUND", + "evidence": "The implementation report defers verification; the three runtime result files contain implementation summaries but no behavioral receipts. The task card/context only declares print-task-context as its executable command.", + "missingBindings": [ + "focused production and test entrypoints", + "Chromium SERVER_NATIVE mutated Main and F3 typed properties", + "browser-equivalent workflow execution", + "missing-provider, malformed-envelope, hash-mismatch, timeout, cancellation and context-only no-mutation cases", + "undo/redo, save/reopen, determinism and aggregate runtime receipts" + ], + "recovery": "Bind the current runtime closure to executable source-backed entrypoints and focused acceptance receipts through repository task generators before declaring completion." + } + ], + "historicalEvidenceModified": false, + "commitCreated": false, + "pushAttempted": false +} diff --git a/tools/web/print-wbv2-live-status.mjs b/tools/web/print-wbv2-live-status.mjs index 9ca74aec7..02837a921 100644 --- a/tools/web/print-wbv2-live-status.mjs +++ b/tools/web/print-wbv2-live-status.mjs @@ -81,6 +81,8 @@ const pushVerification = (task) => { return { path: file, localHead: match?.[1] ?? null, remoteHead: match?.[2] ?? null, equal: Boolean(match && match[1] === match[2]) }; }; const collect = () => { + const autopilot = readJson(`${controlRoot}/autopilot/state.json`); + const autopilotLock = lockInfo(`${controlRoot}/autopilot/owner.lock`); const queue = currentPointer(); const scheduler = readJson(schedulerCheckpointPath); const guardian = readJson(guardianCheckpointPath); @@ -88,21 +90,23 @@ const collect = () => { const schedulerLock = lockInfo(schedulerLockPath); const guardianLock = lockInfo(guardianLockPath); const supervisorLock = lockInfo(supervisorLockPath); + const pythonOwnsScheduler = autopilotLock.alive && schedulerLock.pid === autopilotLock.pid; const handoff = latestHandoff(); - const active = schedulerLock.alive || (guardianLock.alive && supervisorLock.alive); + const active = autopilotLock.alive || schedulerLock.alive || (guardianLock.alive && supervisorLock.alive); let terminalQueue = false; try { const manifest = queue.task ? readJson(`tests/golden/${queue.task}/manifest.json`) : null; const index = readJson("tests/golden/WBV2/task-index.json"); - terminalQueue = !active && index?.activeTask === null && manifest?.status === "done" && manifest?.nextTask === null; + terminalQueue = !active && index?.activeTask === null && manifest?.status === "done" && manifest?.nextTask === null && manifest?.acceptanceComplete === true && manifest?.verificationDeferred !== true; } catch { /* A malformed pointer remains visible as a normal checkpoint failure. */ } const checkpointBlocked = scheduler?.state === "blocked" || guardian?.state === "blocked" || supervisor?.state === "blocked"; // A terminal task can leave a historical blocked checkpoint behind (for // example, after a push retry). The watchdog owns the next planner attempt; // do not report that stale checkpoint as a live execution block. - const blocked = checkpointBlocked && !terminalQueue; + const autopilotBlocked = ["blocked", "provider_blocked", "needs_reconcile", "planning_required", "budget_exhausted", "ready_to_publish"].includes(autopilot?.state); + const blocked = autopilotBlocked || (!autopilotLock.alive && checkpointBlocked && !terminalQueue); const state = blocked ? "BLOCKED" : active ? "RUNNING" : "IDLE"; - const phase = blocked ? "blocked" : scheduler?.state === "running" ? "scheduler-task" : supervisor?.state === "running" ? "task-or-gate" : scheduler?.state ?? supervisor?.state ?? "unknown"; + const phase = autopilotLock.alive || autopilotBlocked ? `python-${autopilot?.state ?? "starting"}` : blocked ? "blocked" : scheduler?.state === "running" ? "scheduler-task" : supervisor?.state === "running" ? "task-or-gate" : scheduler?.state ?? supervisor?.state ?? "unknown"; const observed = new Date().toISOString(); return { schemaVersion: 1, @@ -110,10 +114,11 @@ const collect = () => { state, phase, message: state === "RUNNING" - ? `RUNNING: ${queue.task ?? "unknown task"} is owned by the guardian/supervisor process; wait for its handoff.` + ? `RUNNING: ${queue.task ?? "unknown task"} is owned by ${autopilotLock.alive ? "Python autopilot" : "guardian/supervisor"}; wait for its handoff.` : state === "BLOCKED" ? "BLOCKED: inspect the scheduler/guardian/supervisor checkpoint reason before any write or retry." : "IDLE: no live scheduler, guardian or supervisor lock was found.", queue, - scheduler: { pid: scheduler?.pid ?? schedulerLock.pid, alive: schedulerLock.alive, state: scheduler?.state ?? null, updatedAt: scheduler?.updatedAt ?? null, iteration: scheduler?.iteration ?? null, before: scheduler?.before ?? null, after: scheduler?.after ?? null, latestBatch: scheduler?.latestBatch ?? null }, + autopilot: { pid: autopilot?.pid ?? autopilotLock.pid, alive: autopilotLock.alive, state: autopilot?.state ?? null, phase: autopilot?.currentProcess?.phase ?? null, activeJob: autopilot?.activeJob ?? null, reason: autopilot?.reason ?? null, tokensUsed: autopilot?.tokensUsed ?? 0, providerFailures: autopilot?.providerFailures ?? 0, nextRetryAt: autopilot?.nextRetryAt ?? null }, + scheduler: { pid: schedulerLock.alive ? schedulerLock.pid : scheduler?.pid ?? schedulerLock.pid, alive: schedulerLock.alive, state: pythonOwnsScheduler ? "python-owned" : scheduler?.state ?? null, updatedAt: pythonOwnsScheduler ? autopilot?.updatedAt : scheduler?.updatedAt ?? null, iteration: pythonOwnsScheduler ? null : scheduler?.iteration ?? null, before: pythonOwnsScheduler ? null : scheduler?.before ?? null, after: pythonOwnsScheduler ? null : scheduler?.after ?? null, latestBatch: pythonOwnsScheduler ? null : scheduler?.latestBatch ?? null }, guardian: { pid: guardian?.pid ?? guardianLock.pid, alive: guardianLock.alive, state: guardian?.state ?? null, updatedAt: guardian?.updatedAt ?? null, heartbeatAt: guardian?.heartbeatAt ?? null, restartCount: guardian?.restartCount ?? null }, supervisor: { pid: supervisor?.pid ?? supervisorLock.pid, alive: supervisorLock.alive, state: supervisor?.state ?? null, updatedAt: supervisor?.updatedAt ?? null, iteration: supervisor?.iteration ?? null, before: supervisor?.before ?? null, after: supervisor?.after ?? null }, latestHandoff: handoff, @@ -127,6 +132,7 @@ const format = (status) => [ `阶段: ${status.phase}`, `当前任务: ${status.queue.task ?? "unknown"}`, `parent manifest: ${status.queue.parentManifest ?? "unknown"}`, + `Python autopilot: pid=${status.autopilot.pid ?? "none"} alive=${status.autopilot.alive} state=${status.autopilot.state ?? "unknown"} job=${status.autopilot.activeJob ?? "none"} reason=${status.autopilot.reason ?? "none"}`, `scheduler: pid=${status.scheduler.pid ?? "none"} alive=${status.scheduler.alive} state=${status.scheduler.state ?? "unknown"} iteration=${status.scheduler.iteration ?? "none"} batch=${status.scheduler.latestBatch?.batchId ?? "none"} completed=${status.scheduler.latestBatch?.completed ?? false}`, `guardian: pid=${status.guardian.pid ?? "none"} alive=${status.guardian.alive} state=${status.guardian.state ?? "unknown"} heartbeat=${status.guardian.heartbeatAt ?? "none"}`, `supervisor: pid=${status.supervisor.pid ?? "none"} alive=${status.supervisor.alive} state=${status.supervisor.state ?? "unknown"} iteration=${status.supervisor.iteration ?? "none"}`, diff --git a/tools/web/run-wbv2-guardian.mjs b/tools/web/run-wbv2-guardian.mjs index 63a499232..5513cc621 100644 --- a/tools/web/run-wbv2-guardian.mjs +++ b/tools/web/run-wbv2-guardian.mjs @@ -168,7 +168,7 @@ try { guardianExit = stopSignal === "SIGINT" ? 130 : 143; break; } - if (checkpoint?.state === "complete") { + if (checkpoint?.state === "complete" && result.code === 0) { writeCheckpoint({ state: "complete", restartCount, current: after, supervisorExit: result.code }); break; } diff --git a/tools/web/run-wbv2-scheduler.mjs b/tools/web/run-wbv2-scheduler.mjs index 61374033b..90a2904cf 100644 --- a/tools/web/run-wbv2-scheduler.mjs +++ b/tools/web/run-wbv2-scheduler.mjs @@ -31,9 +31,39 @@ if (!Number.isSafeInteger(pollMs) || pollMs < 0) throw new Error("--poll-ms must if (!Number.isSafeInteger(pushRetries) || pushRetries < 0) throw new Error("--push-retries must be a non-negative integer"); if (pushEnabled && !commitEnabled) throw new Error("--push requires --commit"); +// A preflight must neither claim ownership nor rotate queue/checkpoint files. +if (preflightOnly) { + try { + const pointer = currentTask(); + if (!pointer) throw new Error("queue pointer is missing; completion is unproven"); + parentManifest(pointer); + const check = spawnSync(process.execPath, [abs("tools/web/check-task-context.mjs")], { cwd: root, encoding: "utf8" }); + if (check.status !== 0) throw new Error("task context validation failed"); + const readiness = terminalTask(pointer.task) + ? { ok: true, terminal: true, reason: "accepted_terminal_manifest" } + : sourceMappingReadiness(pointer); + process.stdout.write(`${JSON.stringify({ task: pointer.task, ...readiness })}\n`); + process.exit(readiness.ok ? 0 : 2); + } + catch (error) { + process.stderr.write(`scheduler-preflight-blocked: ${error.message}\n`); + process.exit(2); + } +} + fs.mkdirSync(abs(controlRoot), { recursive: true }); let lockHandle; const acquireLock = () => { + const pythonOwnerPath = abs(`${controlRoot}/autopilot/owner.lock`); + if (fs.existsSync(pythonOwnerPath)) { + const owner = JSON.parse(fs.readFileSync(pythonOwnerPath, "utf8")); + let alive = false; + if (Number.isSafeInteger(owner.pid) && owner.pid > 0) { + try { process.kill(owner.pid, 0); alive = true; } + catch (error) { if (error.code !== "ESRCH") alive = true; } + } + if (alive) throw new Error("the Python autopilot already owns the project"); + } try { return fs.openSync(abs(lockPath), "wx"); } @@ -186,7 +216,13 @@ function terminalTask(task) { const index = JSON.parse(read("tests/golden/WBV2/task-index.json")); const manifestPath = `tests/golden/${task}/manifest.json`; const manifest = fs.existsSync(abs(manifestPath)) ? JSON.parse(read(manifestPath)) : null; - return index.activeTask === null && manifest?.task === task && manifest.status === "done" && manifest.nextTask === null; + return index.activeTask === null && manifest?.task === task && manifest.status === "done" && manifest.nextTask === null + && manifest.acceptanceComplete === true && manifest.verificationDeferred !== true + && Object.keys(manifest.artifacts ?? {}).length > 0 + && Object.values(manifest.artifacts).every((artifact) => typeof artifact.path === "string" + && typeof artifact.sha256 === "string" && !path.isAbsolute(artifact.path) + && !artifact.path.split("/").includes("..") + && crypto.createHash("sha256").update(fs.readFileSync(abs(artifact.path))).digest("hex") === artifact.sha256); } catch { return false; @@ -319,7 +355,7 @@ try { // guardian/supervisor chain. try { const index = JSON.parse(read("tests/golden/WBV2/task-index.json")); - if (index.activeTask === null && index.entries?.[before.task]) { + if (index.activeTask === null && index.entries?.[before.task] && terminalTask(before.task)) { const completedBatchInfo = { ...batchInfo(before), completed: true }; latestBatch = completedBatchInfo; const planned = preflightOnly ? { terminal: true } : planNextBatch(before); diff --git a/tools/web/search-wbv2-batch-source.mjs b/tools/web/search-wbv2-batch-source.mjs index fdafd0e12..5e8a0925f 100644 --- a/tools/web/search-wbv2-batch-source.mjs +++ b/tools/web/search-wbv2-batch-source.mjs @@ -12,7 +12,7 @@ const arg = (name, fallback = null) => { return index >= 0 ? process.argv[index + 1] : fallback; }; if (process.argv.includes("--help")) { - process.stdout.write("usage: node tools/web/search-wbv2-batch-source.mjs [--task ] --pattern [--runtime ...] or --list\n"); + process.stdout.write("usage: node tools/web/search-wbv2-batch-source.mjs [--task ] --pattern [--unit ...] [--runtime ...] [--max-hits ] or --list\n"); process.exit(0); } const task = arg("--task") ?? read("docs/EXECUTION_QUEUE.md").match(/\| 当前任务 \| `([^`]+)` \|/u)?.[1]; @@ -32,6 +32,21 @@ for (const artifact of Object.values(manifest?.artifacts ?? {})) { for (const source of taskRecord?.module?.sourcePaths ?? []) { if (source.startsWith("blender-5.2.0/source/blender/")) sourcePaths.add(source); } +const selectedUnits = []; +for (let i = 0; i < process.argv.length; i += 1) { + if (process.argv[i] === "--unit") selectedUnits.push(process.argv[++i]); +} +if (selectedUnits.length > 16) throw new Error("source context is limited to 16 explicit unit IDs"); +if (selectedUnits.length) { + const inventory = json("tests/golden/WBV2/dynamic-inventory.json"); + for (const id of selectedUnits) { + const unit = inventory.units.find((item) => item.id === id); + if (!unit) throw new Error(`unknown source unit: ${id}`); + for (const location of unit.locations ?? []) { + if (location.path.startsWith("blender-5.2.0/source/blender/")) sourcePaths.add(location.path); + } + } +} const runtimeAllowlist = new Set([ "tools/web/run-wbv2-module-task.mjs", "tools/web/run-wbv2-continuous.mjs", @@ -78,6 +93,17 @@ const runtimeAllowlist = new Set([ "blender-5.2.0/source/blender/web_engine/web_engine_main_state.h", ]); const runtimePaths = []; +// Product workflows are bounded subtasks of the current authoritative task. +const backlogPath = abs("tests/golden/WBV2/web-product-backlog.json"); +if (fs.existsSync(backlogPath)) { + const backlog = JSON.parse(fs.readFileSync(backlogPath, "utf8")); + if (backlog.queueTask === task) { + for (const job of backlog.tasks ?? []) { + for (const file of job.ownedPaths ?? []) runtimeAllowlist.add(file); + } + } +} +for (const file of ["tools/web/deployment-http-server.mjs", "my-tools/wbv2_autopilot.py", "my-tools/run_web_product_migration.py", "tools/web/run-wbv2-scheduler.mjs", "tools/web/run-wbv2-guardian.mjs", "tools/web/check-wbv2-module-execution.mjs"]) runtimeAllowlist.add(file); for (let index = 0; index < process.argv.length; index += 1) { if (process.argv[index] === "--runtime") { const file = process.argv[index + 1]; @@ -101,4 +127,6 @@ if (result.error) throw result.error; if (result.status !== 0 && result.status !== 1) throw new Error(`batch search failed with exit ${result.status}`); const output = result.stdout ?? ""; const hits = output ? output.trimEnd().split("\n").filter(Boolean) : []; -process.stdout.write(`${JSON.stringify({ schemaVersion: 1, task, scope: "batch", pattern, sourcePathCount: sourcePaths.size, runtimePathCount: runtimePaths.length, hitCount: hits.length, hits }, null, 2)}\n`); +const maxHits = Number(arg("--max-hits", "60")); +if (!Number.isSafeInteger(maxHits) || maxHits < 1 || maxHits > 200) throw new Error("--max-hits must be between 1 and 200"); +process.stdout.write(`${JSON.stringify({ schemaVersion: 1, task, scope: "batch", pattern, selectedUnits, sourcePathCount: sourcePaths.size, runtimePathCount: runtimePaths.length, hitCount: hits.length, truncated: hits.length > maxHits, hits: hits.slice(0, maxHits) }, null, 2)}\n`);