## Context `GovernPolicyEngine::evaluate_policies` re-parses the shared `input_json` and `data_json` from text inside every per-policy evaluation: up to `MAX_POLICIES_PER_TRIGGER` (64) parses of documents capped at 1 MiB each, plus one up-front validation parse. Fine for small contexts; measurably wasteful for large ones (worst case ≈ 65 parses of 1 MiB per call — benchmarks by @mcavoj show substantial gains are available on bigger contexts). Follow-up from the !133 review: https://gitlab.com/gitlab-org/auth/glaz/-/merge_requests/133#note_3695014883 (design sketch by @mcavoj included there in full). ## Design (per the review note) `regorus::Value` is `Clone` and documented as "efficiently cloned due to reference counting", and has `impl From<serde_json::Value>` — so the shared documents can be parsed **once per batch** and cheaply cloned per policy: - `evaluator.rs` gains prepared-value variants alongside the existing string-based ones: - `build_engine_prepared(policy_rego, input: &RegoValue, data: Option<&RegoValue>)` — skips the per-policy text parse; the input size check stays at the batch entry point (already enforced once by `validate_input_document`). - `evaluate_discover_prepared(policy_rego, input, data: Option<(&RegoValue, &serde_json::Value)>, limits)` — same `violation`/`deny`/`allow` interpretation; the data/package collision check gets a value-based variant (`reject_data_document_key_collision_value`). - `evaluate_policies` parses input/data once (the validation parse can double as it) and calls the prepared variant per policy. - The string-based `build_engine`/`evaluate_discover`/`debug_evaluate` stay untouched — `debug_evaluate` is single-shot and gains nothing. ## Acceptance criteria - [ ] Shared `input_json`/`data_json` parsed at most once per `evaluate_policies` call - [ ] Per-policy semantics unchanged: same errors, same in-band/whole-call split, all existing tests pass unmodified (except any asserting on parse-error message text) - [ ] A benchmark (or repeatable measurement) documenting the before/after on a large context (e.g. 1 MiB input × 64 policies) - [ ] `debug_evaluate` and the single-policy string path unaffected ## References - Review note with full design: https://gitlab.com/gitlab-org/auth/glaz/-/merge_requests/133#note_3695014883 - Earlier deferral analysis: worst case ≈ 0.2–0.6 s of pure re-parsing per call at the caps (glaz!133 review round 2, finding on per-policy clone/parse) - Related: gitlab-org/gitlab#607650 (trigger-keyed evaluation), glaz!139 (Policy Store REST client) --- ## Implementation plan (2026-08-21, against post-!133 main) Base: branch off `main` (!133 merged). One coordination note: this touches the same `evaluator.rs`/`policy_engine.rs` regions as !141's data cap — land after !141 merges, or expect its one-commit rebase. ### Layer diagram ``` policy_engine evaluate_policies ~ parse input+data ONCE, refcount-clone per policy validate_input_document = already returns parsed serde Value (reused) validate_data_document ~ returns Option<serde_json::Value> instead of () evaluate_policy / catch net ~ takes prepared borrows; catch_policy_panic unchanged evaluator prepare_engine_with_policy = reused unchanged (validate refactor already extracted it) build_engine_prepared (NEW) + policy-size check + add_data(clone) + set_input(clone) evaluate_discover_prepared + shared `discover` tail (extracted from evaluate_discover) debug_evaluate, validate = untouched (single-shot string paths) ``` ### Tasks **T1 — extract the discovery tail (pure refactor).** Pull the post-build half of `evaluate_discover` (package discovery → collision check → `eval_modules` → package-path navigation) into a private `discover(engine, collision_data: Option<&serde_json::Value>)`; split `reject_data_document_key_collision` into a value-based core the string variant wraps with a parse. *AC:* zero behavior change, all tests pass unmodified. **T2 — prepared-document variants.** `build_engine_prepared(policy_rego, input: &RegoValue, data: Option<&RegoValue>)` = `check_policy_size` + `prepare_engine_with_policy` + `engine.add_data(data.clone())` + `engine.set_input(input.clone())` — refcounted clones, no text parse, no input-size check (batch entry enforces it once). `evaluate_discover_prepared(…, data: Option<(&RegoValue, &serde_json::Value)>, limits)` = prepared build + `set_limits_for` + the `discover` tail. *AC:* a prepared-vs-string equivalence test on identical policy/input/data; collision rejection through the value path. **T3 — parse once per batch.** `validate_data_document` returns the `Option<serde_json::Value>` it already parses; after `lookup_key_from`, convert once (`RegoValue: From<serde_json::Value>`; keep the serde half of data for the per-policy collision check, which depends on each policy's package name and cannot move up front). The loop passes borrows through `catch_policy_panic` into `evaluate_discover_prepared`. Delete the "evaluator still re-parses once per policy; deferred" comment — this is the deferral coming due. *AC:* same error split (per-policy `InputSerialization` already cannot occur in a batch — up-front validation gates first); `debug_evaluate`/`validate` untouched; the ~27 interpretation tests unchanged except the private test helper parsing its string arguments itself. **T4 — benchmark.** Criterion dev-dep, `benches/parse_once.rs`: ~1 MiB context × `MAX_POLICIES_PER_TRIGGER` (100) trivial policies through `evaluate_policies`; before/after numbers in the MR description. Fallback if a new dev-dep is unwelcome: an `#[ignore]`d timing test. ### Commits C1 = T1 (`refactor`), C2 = T2 (`feat`), C3 = T3 (`perf`), C4 = T4 (`test`). One MR, ~half a day. ### Compile-time facts to confirm (verified in the review-note design, re-checked by C2's build) `regorus::Value` is refcount-`Clone` with `impl From<serde_json::Value>`; `Engine::add_data(Value)` exists alongside `add_data_json`.